Open-source project
trustwallet/assets avatar
trustwallet/assets

Trust Wallet Assets: thousands of tokens, one check written three times, and no releases to pin to

A comprehensive, up-to-date collection of information about several thousands (!) of crypto tokens.

5,416 stars27,645 forksGoMIT

At a glance

What is it?
A Go repository of token logos and metadata that Trust Wallet and other projects read from, validated by scripts that also exist in a browser app and a GitHub app, with the MIT licence sentence scoped to scripts and documentation rather than to the data. The version comes from a git describe fallback, the linter is pinned to golangci-lint v1.50.1 and installed by piping a script, and one library dependency is pinned to a September 2024 commit.
Who is it for?
This repository is best understood as a review pipeline that happens to store its output as JSON, not as a published dataset. That framing answers most of the questions a user arrives with.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • trustwallet/assets5,416 ★ · +31
Star history
Repository2026-09-232026-11-15
trustwallet/assets5.4k5.4k

31 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

No releases, so the version comes from the fallback branch of git describe

The repository has no GitHub releases, which is unusual for a Go project and entirely normal for a data repository. It shows up in the build, because the Makefile computes its version from tags with a fallback:

code
VERSION := $(shell git describe --tags 2>/dev/null || git describe --all)
BUILD := $(shell git rev-parse --short HEAD)

The first line tries to describe a tag and, failing that, describes any ref. The second takes the short commit hash. Both are then injected into the binary at link time:

code
LDFLAGS=-ldflags "-X=main.Version=$(VERSION) -X=main.Build=$(BUILD)"

For anyone consuming this as a dependency or a data source, the practical consequence is that you track a commit and you re-pull often, because there is no version boundary to reason about.

The linter is a 2022 release, installed by piping a script from master

`make lint` depends on a target that installs the linter if it is not already present, and that target pipes a remote script into a shell:

code
curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- v1.50.1

Two details sit in one line. The script is fetched from the master branch, which moves, while the version is pinned, so the installer is unpinned even though the artefact is not. And v1.50.1 sits alongside a go directive of 1.19 in go.mod.

The guard around it is worth reading too. The condition is written as ifeq (,$(wildcard test -f bin/golangci-lint)), where a shell style test -f has leaked into a make function call. Make's wildcard then treats test, -f and bin/golangci-lint as three separate patterns, so the check works only because the other two cannot exist. It is the kind of line that works until someone tidies it and changes what it matches.

One set of checks, implemented three times

The page explains that the repository contains a set of scripts for verification of all the information, implemented as Golang scripts, reachable through `make check`, executed in the CI build, and covering the whole repository. Then it says similar check logic exists in two other places.

The assets-management app does similar checks on the changed token files in a pull request, and can be run from a browser environment. The merge-fee-bot does them as a GitHub app, writes the result into a pull request comment, and runs in a non-browser environment.

So there are three implementations of one rule set, selected by where you happen to be: the whole repository on the command line, the changed files in a reviewer's browser, and the changed files in a comment. That is also the obvious place for the three to disagree. The Go implementation is the one that CI runs over everything, which makes it the one to trust when a browser check and a comment disagree.

Brand new tokens are refused, and the bar is a judgement about circulation

The submission section leads with two bolded exclusions rather than an invitation. Brand new tokens are not accepted, and projects have to be sound, with information available, and of non minimal circulation, with the limits linked to a page on the developers site rather than stated here.

So the gate is not technical. What matters is whether there is enough of it in circulation and whether anyone has published information about it. That is a judgement, which means it is applied by a person reading a submission.

The tooling supports that process rather than automating it. Most additions go through the Assets web app, which needs a GitHub account, and the quick starter sends you to the developers site for the repository structure and contribution guidelines. The make targets are the escape hatch for maintainers: `make add-token` with an asset id creates an info.json file as a template, and the two tokenlist targets add the same id to tokenlist.json and to tokenlist-extended.json.

The MIT sentence covers scripts and documentation, not the data

The licence section is one sentence and it is scoped. The scripts and documentation in this project are released under the MIT License. The token information, the logos, the tokenlist files and the knowledge directory are not named in that sentence.

For a repository whose entire content is data, that distinction is the whole licence question. Anyone intending to redistribute the metadata, mirror the logos into an application, or build a product on top of the token list needs to read the LICENSE file itself rather than rely on the readme's summary, because the readme's summary is about the tooling.

It is also a coherent choice rather than an oversight. The scripts are the part the project wrote and wants contributors to reuse under a permissive licence, while the metadata is assembled from thousands of third party submissions where a blanket grant would mean very little. The repository's own metadata record does list MIT, so the two sources agree in name while the readme is narrower in scope.

The main library dependency is pinned to a September 2024 commit

The module is github.com/trustwallet/assets with a go directive of 1.19, and the direct requirements are small: logrus, cobra, and three Trust Wallet libraries. One of those three is not pinned to a release:

code
module github.com/trustwallet/assets

go 1.19

require (
	github.com/sirupsen/logrus v1.9.0
	github.com/spf13/cobra v1.7.0
	github.com/trustwallet/assets-go-libs v0.3.9-0.20240905070109-9da7e7c4847a
	github.com/trustwallet/go-libs v0.7.3
	github.com/trustwallet/go-primitives v0.1.32
)

The pseudo-version on assets-go-libs encodes a commit dated 2024-09-05. A pseudo-version like that is what the go tooling produces when a module has no usable tag, so that dependency is tracking a specific commit rather than a series, and it has not moved in the time between that commit and now.

The indirect list explains the rest. It includes gin-gonic/gin and several prometheus packages, a web framework and a metrics client, which a command line checker has no use for.

Trading pairs come from two exchanges, with floors and overrides in one config file

Supported trading pairs live in tokenlist.json files, and they are maintained rather than hand written one by one. Pairs can be updated from Uniswap on Ethereum and from PancakeSwap on Smartchain using the update script, with the changes checked in rather than applied automatically.

The selection criteria are not in the script. Minimal limit values for including a trading pair are set in a config file under .github, named assets.config.yaml, and the same file also carries force-include and force-exclude options. So inclusion is threshold based by default, with named exceptions in both directions for anyone who needs a pair that the thresholds would drop or wants to suppress one that would pass.

The update command is `make update-auto`, and the page says it is executed regularly by a GitHub action.

Open to anyone to submit, no partnership with anyone, rules changeable at any time

The disclaimer is four sentences and they pull in different directions. Anyone can submit new assets, which is the point of a community maintained collection of thousands of tokens. That does not mean the Trust Wallet team is in direct partnership with all of the projects. Projects deemed to be scam or fraudulent will be rejected after careful review. The team reserves the right to change the terms of asset submissions at any time, citing changing market conditions, risk of fraud, or any other factor they consider relevant.

The last paragraph is the enforcement mechanism, and it names the behaviour that gets you removed: spam like activity, including but not limited to mass distribution of tokens to random addresses, results in the asset being flagged as spam and possible removal.

Read together, this is a repository that is deliberately open at the front and filtered afterwards, with judgement applied after submission rather than a technical gate in front of it. For a consumer of the metadata that is the important part: presence in this repository is evidence that someone submitted an entry, and the rules under which an entry exists can change without notice.

Editorial conclusion

This repository is best understood as a review pipeline that happens to store its output as JSON, not as a published dataset. That framing answers most of the questions a user arrives with. There is no release to pin, so consumers track a commit. Similar validation logic is implemented three times, once for the command line, once for a pull request in a browser and once for a GitHub app, which means the authoritative check is the Go one and the other two are reimplementations to keep. The inclusion bar is a judgement about circulation and available information rather than a technical criterion, enforced by review after submission, and the disclaimer says listing does not mean direct partnership with all of the projects while reserving the right to change the rules. Two things to verify yourself before relying on it. Read the LICENSE file rather than the readme's summary, since the MIT sentence names scripts and documentation. And remember that anyone may submit an entry, and spam-like submissions are handled by flagging and possible removal.

Frequently asked questions

What is the trustwallet/assets repository for?

It is a collection of information about several thousands of crypto tokens. Trust Wallet uses the token logos from this source alongside a number of other projects, and the repository also carries token info from several blockchains, dApps and staking validators, including data that is not available on chain.

Can I add a brand new token to trustwallet/assets?

Not directly. Brand new tokens are not accepted, and the project has to be sound, with information available, and of non minimal circulation. Most additions go through the Assets web app, which needs a GitHub account.

What does make check do in trustwallet/assets?

It builds the Go binary and runs bin/assets check, executing the validation checks over the whole repository. The same check is run in the CI build, and similar logic exists in the assets-management app for changed token files in a pull request and in the merge-fee-bot GitHub app.

Which licence applies to trustwallet/assets?

The readme states that the scripts and documentation in the project are released under the MIT License. That sentence is scoped to the tooling rather than to the token metadata and logos, so read the LICENSE file before redistributing the data.

How are supported trading pairs maintained in trustwallet/assets?

They are stored in tokenlist.json and updated from Uniswap on Ethereum and PancakeSwap on Smartchain by an update script, with the changes checked in. Minimal inclusion limits, plus force-include and force-exclude options, live in the assets config file under .github.

Official sources

  1. Issues
  2. License: MIT
  3. Project website
  4. README
  5. trustwallet/assets on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/trustwallet-assets.svg)](https://hysenlabs.com/projects/trustwallet-assets)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/trustwallet-assets.svg)](https://hysenlabs.com/projects/trustwallet-assets)

Was this useful?