Spam tokens. They’re horrible, and they’re everywhere¹. They just show up in your wallet. And there’s nothing you can do about it since anyone can send you tokens without your permission.

Sometimes these tokens are designed to get you to visit a website, for example, a token called UniswapLP.com. (⚠️Don’t go there!)

Sometimes they’re designed to confuse you, e.g., a token named “AAVE” which isn’t the AAVE token. Why would someone do that? Usually to steal your real AAVE tokens.

Sometimes these “free” tokens are part of a larger pump-and-dump scheme. They aren’t nefarious to you, they’re just annoying.

In their aim, spam tokens are just like spam emails.

Most people rely on centralized providers to process their email. For example, if I use Gmail (owned by Google) to send my mother a message to her Hotmail account (owned by Microsoft), two companies with large R&D budgets get the chance to review my email to decide whether or not it’s spam. If Google decides it’s spam, it won’t even send it on to Microsoft. If Microsoft decides it’s spam, it may reject it or, out of an abundance of caution, put it in my Mom’s spam box instead of her inbox.

This all happens without most of us even thinking about it. Yes, the system inevitably marks some legitimate email as spam, but, on whole, it does a good job of keeping huge amounts of junk out of inbox. In addition, email clients let users mark spam email that made it through the filter.

Crypto is peer-to-peer. When someone sends you a spam token, there are no organizations with large R&D budgets processing the transaction. It’s direct. That’s the beauty of crypto.

That’s also the reason we can’t avoid spam tokens. They show up in our wallets, whether we like it or not.

When spam email ends up in your spam box, our email provider isn’t eliminating it. Instead, it’s hiding it so that you won’t see it unless you go looking explicitly. This can be frustrating, and often confusing, even for those of us who know exactly how the process works.

Hiding spam tokens can be equally confusing, if not more so.

But before we can talk about hiding spam tokens, we need to take a little detour to make sure we’re all on the same page. We need to understand where we might come across these spam tokens in the first place.

A wallet is a piece of software or hardware that holds public and private keypairs². These are a bit like username (public), password (private) pairs that give you access to something like your bank account. One critical difference is that a public/private key gives you ownership – not just access – to blockchain addresses that “store” your tokens.

A crypto wallet also holds the list of addresses owned by your public/private keys. This is why we decided to call wallets “wallets” even though they aren’t wallets like the one you carry around in your purse. Sometimes analogies help, but In this case, the analogy is confusing! Nonetheless, it’s the term everyone uses, so I’ll stick with it.

If you’ve spent any time in crypto you are no doubt familiar with various types of wallets. We have browser-based wallets like 

. And finally we have wallets stored at institutions like 

, which aren’t wallets at all. Those “wallets” are accounts, just like your bank account.

If you have a wallet you can see its contents, i.e., the tokens stored at one or more addresses managed by the wallet. But it turns out that there are other ways of seeing these tokens.

A wallet lets you explore the tokens (or transactions) associated with an address. But other software does as well. Addresses, after all, are public, as are all transactions associated with those addresses

I lump all of these non-wallets into a category I call “Transaction Explorers”. This class of software is mainly aimed at three categories of people:

Developers tend to be happy with relatively crude interfaces that allow them to see as much data as possible. In Ethereum, the most popular explorer is 

. Copy paste an address into its search bar and you can see every single transaction associated with it. Try it with one of Vitalik Buterin’s addresses: 

0xab5801a7d398351b8be11c439e05c5b3259aec9b

. You’ll be amazed by the volume of spam he has to deal with!

Traders like to know what they have. A popular tool for DeFi degens is 

. It does a great job of showing you what you own and how much it’s worth. Again, try it with 

And finally we have “serious” tools for accountants. These things are thorough and approach the problem from a completely different perspective. They don’t bother showing you a picture of your latest NFT purchase, but they do things like calculate the rewards you earned on Uniswap. Why? Ask the taxman. Our favorite explorer in this category is 

Wallets and transaction explorers are the equivalent of your email client: Gmail, Superhuman, Apple Mail, Outlook, etc. We use these email clients to send email to other email clients, but, as I mentioned earlier, that process depends on large corporations with the means (AIs) to deal with spam. In a peer-to-peer world, that isn’t possible.

This means that spam detection and spam processing are the responsibility of each wallet or transaction explorer. Everyone has to roll their own. Let’s look at three different approaches used in the industry:

This is the approach taken by the MetaMask wallet. Tokens must be approved (“imported”) in order for MetaMask to display them. This is a great strategy for people who understand what’s going on but it’s very confusing to new users.

If, for example, I send you a token that’s never been imported into your MetaMask, you won’t see it. To make matters worse, the approval process is complicated. You need to know the token’s contract address. And who knows where to find that?!

This is the most common approach. Show users all the tokens at an address. That’s what Zapper does, and no one seems to mind.

Some users deal with this problem by sending spam tokens to addresses setup for this very purpose. 

 is a good example. The only problem with that is that you spend gas getting rid of your spam!

This is where we get into interesting territory. There are currently three approaches being used to identify and manage spam tokens: home-grown application level strategies, user flagging, and centralized repositories of spam token addresses.

Some wallets and transaction explorers are coming up with their own internally-developed heuristic to generate a whitelist or blacklist of tokens that is then used by their applications.

 for example. Whether this list is algorithmically generated, hand-curated, or some combination isn’t relevant. What matters is that many projects are re-inventing this wheel, because blocking or hiding spam is so critical to the user experience.

When a wallet or transaction explorer notices a spam token, she can mark it as spam and the software hides it. This allows her to manage her own universe of tokens. Unfortunately, this puts the burden on a user who may not know enough to determine whether or not a token is spam. As I mentioned, sometimes spam tokens have the exact same name as legitimate tokens. If you have two AAVE tokens in your wallet, which is the real one? Even for a knowledgeable user, this technique only works well as long as the volume of spam is manageable.

An alternative to end user flagging is crowdsourced flagging. Etherescan runs a project to support this: 

https://info.etherscan.com/etherscan-token-reputation/

. Both are a good resources for anyone having to manually mark their spam tokens.

What if we had a collaboratively-developed source of token legitimacy, accessible by either a website like Etherscan’s or API? That the information could be used by developers so that they didn’t have to reinvent the wheel or place the research burden on their users?

It would be fantastic for the entire crypto industry. Unfortunately, it doesn’t exist yet.

Luckily Credmark is working on this problem and plans to put a proposal forward in the coming weeks. We’re hoping to make it the best of all worlds: decentralized, open source, and collaborative. It’s an ambitious goal, but the industry needs it, and we have the infrastructure to support it.

¹ In 2022 alone, Solidus Labs estimates that over 120,000 scam tokens were deployed: https://www.soliduslabs.com/reports/rug-pull-report.

² Strictly speaking, this isn’t true. Since a blockchain is a ledger it only needs to keep transactions (credits and debits) associated with an address. Your balance is derived from the transactions. Talking about spam tokens as “unwanted transactions” would therefore be more accurate than talking about spam tokens, but a lot more confusing!

³ Exodus, like many wallets, is available on multiple platforms like iOS, Android, and even desktop.

⁴ Full disclosure: Picante is a Credmark customer.

 runs a financial modeling platform powered by reliable 

 around the globe and across industries.

Our 

 of quants, developers, and modelers actively build models for the DeFi community by leveraging our data API and tools. Join the growing community and together we will advance the next-generation financial system.

How to Address it

Dealing with Spam Crypto Tokens

Everyone who uses our crypto accounting app, 

, knows how much data we process. We currently track and process wallets for our customers across three chains (Ethereum, Polygon and BSC), with more coming soon! For each wallet we analyze every transaction in order to give our customers a complete picture of their current position as well as an understanding of their history.

Managing all this data efficiently isn’t easy. Luckily we have some first-rate backend devs on the case. 💪

Although we manage gigabytes of client data, we don’t manage blockchain nodes to directly access that data. For that we use a Web3 library and Credmark, an API provider that goes way beyond traditional APIs.

When we started building Picante we decided to make it multi-currency by default, so we needed to price tokens in multiple fiat currencies.

Every crypto price API we looked at only returned prices in USD, so we also needed to find an F/X API. Credmark was the only exception. It let us retrieve token prices in USD, EUR, GBP, and a bunch of other currencies.

The cost and complexity of using two API for something as basic as pricing made choosing Credmark a no-brainer.

After we started using Credmark’s API we began chatting with their team in their Discord and discovered that they weren’t just regurgitating prices from centralized exchanges.

They were computing prices based on decentralized exchange data, which is completely public. Once we understood what they were doing we realized that DeFi prices are bound to become the gold standard in crypto. It makes no sense to build decentralized finance tools on top of centralized exchange data!

Things got more interesting when we talked to them about work in progress. It turns out that they are working on a Portfolio API that will allow us to retrieve transactions in bulk instead of having to rely on the very slow Web3 library we are currently using. That will be a huge improvement.

And finally we walked through their plans for supporting multiple chains and realized that their approach was going to make our job easy. Any API call will work on any supported chain. All we have to do is send in a different chain ID.

Credmark’s Token and Portfolio APIs are great, but their DeFi API is the reason we’re planning to leverage Credmark in the long term.

It’s a bit complicated, so I’ll explain how we learned about it, and then try to explain how it works.

One of our customers had a lot of Uniswap and SushiSwap LP positions. We could see the corresponding tokens (ERC-20s and NFTs) in their wallets but we couldn’t price them. LP positions are pretty complicated and don’t fit the standard token pattern. Each one involves two tokens and a reward. To make things worse, there’s no such thing as a “generic” LP token. Each exchange works differently.

We asked Credmark if by any chance they’d be adding support for LP position pricing to their Token API. They told us that was unlikely – “not generic enough” – but that they could build custom models to give us the data we needed, and that we could access the data using their DeFi API.

We worked with them to define what we needed – how the results should be structured and which DEXes to prioritize – and within a few days they sent us endpoints to test. We were blown away.

It turns out that Credmark has developed a platform that allows them to build any model on top of blockchain data as well as any other external data. When they deploy those models they are immediately accessible via their DeFi API. This means that we can ask them to price any exotic instrument we come across, and they can do it. It also means that they can build much more complicated things (e.g., risk modeling) that may or may not be on our roadmap 😉

We have a well-defined roadmap, but it’s always in flux thanks to customer feedback. A lot of the work we do ourselves, but writing efficient code on top of massive amounts of blockchain data is beyond our mission. Luckily, we can rely on Credmark for that. We’re convinced that this is going to be a great partnership.

https://www.linkedin.com/company/picanteio/

Guest Post

Why Credmark?

How to install and run the Model Framework

In March 2022, we launched the open beta of the Credmark Model Framework (“CMF”)¹,. At that time, working with the CMF was simple but restrictive. Developers could build models locally, deploy them, and then access them via an API. Since then we have turned the CMF into a full-fledged development environment for quants, data scientists, and programmers.

In March, working with the CMF required developers to follow a three-stage cycle.

 to run those models in their local environment. 

And third, once models were fully tested, developers could make a pull request to have their models deployed into the Credmark Gateway.

As we developed a larger number of models with increasing complexity, our initial development system became a bottleneck. Debugging and experimenting were difficult. We needed a REPL environment, so we built the CMF Console.

The CMF Console provides an interactive development environment equivalent to an IPython shell. In that environment, developers have access to CMF data structures, base models, Web3, and our indexed data, just as they do when their models are run in production. They can therefore experiment and explore until they are ready to commit to building a deployable script.

Taking the Console idea one step further, we found a way to embed the CMF into a Jupyter Notebook and any Python script. Setup instructions can be found here².

Once deployed, models can be called using the 

. This allows any developer to embed model output into an application.

The following diagram illustrates how model development works using the CLI script 

This setup requires a local installation of Python, framework and models, which has been documented 

(2) the model’s inputs, in this case the JSON dictionary

Block number defaults to the latest available, and chain ID defaults to Ethereum Mainnet. Optional arguments include:

-b to specify the block number at which the model should be run, and

the CMF’s builtin types (Token, Contract, Account, etc.),

past states of the blockchain, and of course

This allows developers to leverage a rich ecosystem of data analytics and machine learning libraries to process blockchain data.

When we are inside the local directory for our models repo

, we can launch the CMF Console as follows:

By default, the context is created for the latest block. Optionally, we can add 

when launching the Console to specify a block number. 

This is a CMF-enhanced IPython console. For example, we can type models.<tab> to show the list of models that can be run.

Returning to the example used to demonstrate the CLI tool, let’s run the price.cex model in the Console:

In this environment, we can use the rich types defined in the CMF for Web3 and DeFi.

We can see the definition of the model price.quote in the 

Let’s pay particular attention to the input and output types.

, which is a data transfer object (DTO) that contains two fields, 

. A Currency is a factory which can create objects of type 

Let’s change our call to pass the model a 

By default, the result is a Python dictionary derived from a JSON object. We can, however, specify the type of the output and the result will be cast to that type (if possible of course).

In this case, we want our return value to be an object of type 

. We can then query that object as needed.

So far we’ve used the Console the same way we used the CLI tool, to run a model. Now, let’s use it to do a bit of exploration.

 object represents an ERC-20 token contract. It exposes the ERC-20 interface as object properties, e.g., 

 etc. to get their values. Below is the code and the Console’s output.

. With objects of either class, we can call associated smart contract functions. For example, we can load the Uniswap V3 NFT contract and look up the owner for 

 122. Below is the code and the console’s output.

The NFT contract has a function to look up for the position given a NFT ID.

0x6B175474E89094C44Da98b954EedeAC495271d0F 

0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

To obtain the exact amount of tokens, the user will have to be familiar with Uniswap v3’s documentation. This has been encoded into two models, 

, which have been deployed and are therefore usable by anyone using the CMF.

The first model takes an address as input and the second model takes the NFT id. Let’s run these models. The output of the two models are slightly different because 

  returns a list of positions of this LP and 

 object to run models. With models, we need to change the dash “-” in the model name to underscore “_” to make the model name conform to Python’s naming convention. Alternatively, we can use function 

We can obtain in-line help from the model with a prefix of question mark “?”. It describes the model’s input and output in detail.

In some cases we may want information about our current context. For example, we can get the 

As you can see, the CMF Console allows interactive exploration which quickly becomes an indispensable part of model development.

As wonderful as the CMF Console might be, it can’t beat the same functionality embedded into a Jupyter Notebook!

 repository. We also needed to install the 

 repository so that we edit and run models locally. After cloning the repository:

Copy and paste the following code into a Jupyter notebook to set up the CMF environment.

 to None we will always use the latest block. This can of course be changed at any time.

We can now write code as we did in the CMF Console.

To run a model, we use the context object from the CMF. There is a 

We can of course ask the context for its block number.

We can generate pandas DataFrame from the output of some models and use those for data analysis.

Credmark Model Framework

A Millions Ways to use the CMF

Vineet’s Model Spotlight blog series is designed to highlight models deployed on the 

. Some will be highlighted because they’re generally useful, some because they are complicated and require some background, and others simply because Vineet finds them interesting.

These models are developed using the Credemark Model Framework (CMF). Model concept and reference docs are available 

Need to get the price of a token? Use the 

 model to get the price of a token in terms of other tokens as well as fiat currencies. The model lets you retrieve the latest price as well as the price at any time in the past. This model provides prices retrieved from “CEXs” (Centralized Exchanges) via Chainlink and “DEXs” (Decentralized exchanges) including Uniswap, Sushiswap, and Curve.

For more information about how we compute prices from DEX data, read 

This model takes 3 parameters: base, quote, and prefer.

Token “address” and “symbol” are case insensitive.

You can find the list of Credmark-supported symbols in the 

Quote currency supports fiat currencies. You can find these special tokens in the 

This model outputs src and address of the quote token/currency along with the price.

The best way to understand how to use a model is by example. Here are three.

Example 1: Get the latest price of ETH in USD

In order to get the latest price in USD, you can omit the quote parameter as it defaults to USD.

In the output above, you can see that the model ran at block number 16097280 which was the latest block available at that time.

If you look closely at the output’s “src” parameter, you’ll notice that the output came from DEXs using Uniswap v2, Sushiswap and Uniswap v3 pools.

The quote address “0x0000000000000000000000000000000000000348” in the output is the 

Example 2: Get the latest price of WBTC in ETH at block number 13916166 (Jan-01-2022 12:00:03 AM +UTC)

As WBTC is present in the credmark’s accepted token list, we can use the symbol for legibility.

In the output above, you can see that I ran the model at block number 13916166 which we specified in the input.

Since no preference was set, the model returned dex price. The quote address “0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee” in the output is the special address of ETH.

Example 3: Get the latest cex price of AAVE in UNI

Let’s switch things around a bit here and use a token address instead of a symbol in the model input.

Address of AAVE: 0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9

Address of UNI: 0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984

And we want the CEX-derived price so we’ll set the preference to cex in the input.

In the output above, the model ran at block number 16097280 which was the latest at the time of running the model.

And as you can see in the “src” field, it returned the computed CEX price using Chainlink.

price.quote

Vineet's Model Spotlight

Access the Sharpe ratio for DeFi on the Credmark Terminal

, Credmark is all about producing and organizing data that we make available through our APIs. Moreover, it is important to us to give you examples and visualizations of this data in order to highlight the possibilities that lay beyond the raw data. Thus, this little series of posts will offer you some pathways to dig deeper into this data and spark your ideas to make use of it.

, we took a deep dive into the Balance Ratio and how the recent events from the FTX meltdown can be traced in some on-chain metrics. Today in Part 2, we will look more closely at another important metric that is well-known in TradF: the Sharpe Ratio.

Okay,... we are not here to glorify the existing financial system. It is broken in many ways, and we need to build a better one! But…some of these folks came up with pretty good models and metrics to explain how this whole system works, and they did this a long time ago. Many have withstood the test of time. One of these modelers was Wiliam F. Sharpe who came up with the eponymous Sharpe ratio in 1966! The Sharpe ratio describes the risk-adjusted returns of an asset compared to a risk free asset. Generally speaking, riskier assets should yield higher returns to compensate for the additional risk, and the Sharpe Ratio is a way to measure that. Pretty cool, huh?

If you are a math geek, please visit our 

 and explore how the formula is calculated. We spent a lot of time explaining the concept and how it is applied to DeFi.

 will do this work for you and just show you the results. You only need to select the tokens of your choice and you will be able to compare their returns against each other. It is that simple. All you have to do is go to the Terminal and navigate to the 

Ok…yeah there are some weird graphs and numbers, but how will that help you? To recap, Sharpe Ratio is a number that allows comparison of different assets and portfolios in terms of risk-adjusted returns.

As a rule of thumb, Sharpe ratio numbers 

, anything between 1.0 and 2.0 is acceptable and anything below 1.0 is considered bad. Thus, the Terminal gives you an easy option of selecting the tokens you like and comparing them over a period of time.

If you hold some ETH, SHIB and AAVE Token, you can easily track their numbers (Spoiler alert: they all performed pretty bad recently) but keep in mind that we look at very short timeframes of 30, 60 or 90 days here.

Insight from the Sharpe Ratio can be implemented to evaluate if tokens are worth the risk. Do they perform dramatically better then some so-called risk-free assets like 10y Treasuries or are they even worse? This is a very important question, especially if you manage a big portfolio of different assets and tokens. The Sharpe ratio might be a useful indicator to identify tokens that are underperforming, especially if you combine them with other metrics like volatility. But we will leave this for you to decide.

Again…the Terminal proposes a use case for Credmarks data. It will not be perfect, it is just a demonstration of what you could do. It is not the ultimate truth you should base any financial decision upon but it should trigger your creativity and broaden the entrance into the DeFi rabbit hole.

The Credmark Terminal and Sharpe Ratio

Visualizing On-Chain Data (Part 2)

On-chain data is very powerful. It contains the truth about everything that has ever been immutably written in digital stone. But it is a lot of data. Our Credmark ETL has thus far recorded 16 GB of data

So if you are looking to understand this massive amount of data, you need to use tools. And one of the most efficient tools to understand whopping amounts of data is to visualize it and look for patterns.

At Credmark we organize and produce data, but we don’t build visualization tools. Nonetheless, we wanted to see it ourselves, and we wanted to show others an example of the data we produce. We wanted to connect all the dots to show what we have to offer. Ideally, we wanted to inspire people to think even further about the possibilities that lay beyond the raw data.

For us, it was important to demonstrate the blend between on-chain data and useful risk analysis for DeFi. So we built a showcase, the 

Sure, there are dashboards out there….there are thousands of them. So why release yet another one?

Well, simple. Ours is different. And we don’t only mean the nice design and the interactivity. Most importantly, the data that drives this dashboard is different. This data that has not been seen in any other dashboard. This data is the product of financial risk analysis models that use on-chain data as their source. These models were built and deployed on the Credmark Platform.

As we are very proud of what is possible with the Terminal, we want to get a step further and dive into some “real world” examples, to show how you can visualize our data from the Terminal to gain insights into what is going on in the markets. This data, of course, is also directly available on our platform or through one of our APIs.

We will now highlight some of the metrics we have in the Terminal. The first one will be the 

2022 is a weird time to be in Crypto. Some heavy macro events pulled us down. We had the Terra / Luna debacle as well as the fallout of 3AC, BlockFi, Voyager, Celsius….but the biggest 💩 of all was set to come in the form of SBF and his Alameda / FTX empire.

While FTX was a centralized exchange (CEX), they (and Alameda even more) had their claws in DeFi as well. And as soon as they leave their centralized orderbooks and OTC trading desks, and enter the main stage on the blockchain, they leave traces. And we are able to pick them up.

Liquidity is king... but for which tokens?

So with every crisis there comes the liquidity crunch. Degens flew out from risky assets into some safe havens like USDC or DAI. But what about other so-called stablecoins? Remember that Alameda was a major user of Abracadabra, and they used FTT (FTX´s own utility token) to mint Magic Internet Money (MIM). And they minted A LOT. As on November 3rd, more than 35% of the outstanding MIM supply was backed by FTT¹.

As the rumors about Alameda surfaced and CZ officially announced his selloff plan for FTT, users flew from MIM. And you could follow it live on the biggest decentralized stablecoin exchange of all….Curve.

Here we see some direct insights that the Terminal offers us. We see the trading volume and total value locked (TVL) in the 3Crv/MIM pool but, most importantly, we see the Balance Ratio on the top left.

In short, the Balance Ratio shows how unbalanced the pool is. A number close to 1 means perfectly balanced, so if there are two assets in the pool, each one makes up roughly 50%. When there are 3 assets in the pool and each individual one is about 33%, you would consider this pool also perfectly balanced and the Balance Ratio would show a number close to 1.

The Balance Ratio of the 3Crv/MIM pool reached a low of 0.3535 on Nov 8. The Balance Ratio recovered recently, but the Curve pool is still very unbalanced towards MIM with over 86%.

People were selling MIM against the other stablecoins of the pool, thus causing sell-pressure against the peg of MIM. This finally caused MIM to depeg to $0.95 on Nov 8th but soon restored the peg again.

But not only was MIM under pressure, so was USDT, which raised concerns worth looking at. The 3Pool on Curve (DAI/USDC/USDT) shows some significant imbalance as well, with a share of 13.9% DAI, 12.5% USDC, and 73.5% USDT, instead of the ideal 33% split.

You will see the change in the Balance Ratio chart for the 3pool in the Terminal as well as rise in the trading volume. The Balance Ratio tanked from nearly 1 to 0.3634 while the Trading Volume spiked from below $100m daily volume to over $2b.

You can draw your own conclusions from these charts, but in general, investors seemed to limit their exposure to USDT and once again favor USDC and DAI instead.


Imbalances in Curve pools should always be watched closely as they are indicators that something is going on in the markets. So every savvy investor should pay attention to this very important metric and Credmark´s data, available via our APsI or the Terminal, should be your go-to source.

Insights from the FTX implosion (Bankless Substack)

Credmark Blog

For the latest technical analysis, partnerships, and community updates