feat: tokenlists resolver

package.json

@@ -12,7 +12,8 @@
     "start:test": "dotenv -e test/.env.test yarn dev",
     "test": "PORT=3003 start-server-and-test 'yarn start:test' http://localhost:3003 'dotenv -e test/.env.test yarn jest'",
     "test:integration": "dotenv -e test/.env.test yarn jest --runInBand --collectCoverage=false test/integration",
-    "test:e2e": "PORT=3003 start-server-and-test 'yarn start:test' http://localhost:3003 'dotenv -e test/.env.test jest --runInBand --collectCoverage=false test/e2e/'"
+    "test:e2e": "PORT=3003 start-server-and-test 'yarn start:test' http://localhost:3003 'dotenv -e test/.env.test jest --runInBand --collectCoverage=false test/e2e/'",
+    "test:unit": "yarn jest --runInBand --collectCoverage=false test/unit"
   },
   "dependencies": {
     "@adraffy/ens-normalize": "^1.10.0",
@@ -57,4 +58,4 @@
     "start-server-and-test": "^2.0.3",
     "ts-jest": "^28.0.4"
   }
-}
+}

src/constants.json

@@ -6,7 +6,7 @@
   "resolvers": {
     "avatar": ["snapshot", "ens", "lens", "farcaster", "starknet"],
     "user-cover": ["user-cover"],
-    "token": ["trustwallet", "zapper"],
+    "token": ["trustwallet", "zapper", "tokenlists"],
     "space": ["space"],
     "space-sx": ["space-sx"],
     "space-cover-sx": ["space-cover-sx"]

src/helpers/tokenlists.ts

@@ -0,0 +1,123 @@
+import { getAddress } from '@ethersproject/address';
+
+type TokenlistToken = {
+  chainId: number;
+  address: string;
+  symbol: string;
+  name: string;
+  logoURI: string;
+  decimals: number;
+};
+
+type AggregatedTokenList = TokenlistToken[];
+
+const TOKENLISTS_URL =
+  'https://raw.githubusercontent.com/Uniswap/tokenlists-org/master/src/token-lists.json';
+const REQUEST_TIMEOUT = 2500;
+const TTL = 1000 * 60 * 60 * 24;
+let aggregatedTokenList: AggregatedTokenList = [];
+let lastUpdateTimestamp: number | undefined;
+
+function isExpired() {
+  return !lastUpdateTimestamp || Date.now() - lastUpdateTimestamp > TTL;
+}
+
+function normalizeTokenListUri(tokenListUri: string) {
+  if (!tokenListUri.startsWith('http') && tokenListUri.endsWith('.eth')) {
+    tokenListUri = `https://${tokenListUri}.limo`;
+  }
+  return tokenListUri;
+}
+
+function normalizeTokenLogoUri(logoUri: string) {
+  if (logoUri.startsWith('ipfs://')) {
+    logoUri = `https://ipfs.io/ipfs/${logoUri.slice(7)}`;
+  }
+  return logoUri;
+}
+
+async function fetchListUris() {
+  const response = await fetch(TOKENLISTS_URL, {
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+  });
+  const tokenLists = await response.json();
+  const uris = Object.keys(tokenLists);
+
+  return uris;
+}
+
+async function fetchTokens(tokenListUri: string) {
+  tokenListUri = normalizeTokenListUri(tokenListUri);
+
+  try {
+    const response = await fetch(tokenListUri, {
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT)
+    });
+    const tokens = await response.json();
+    if (!tokens.tokens || !Array.isArray(tokens.tokens)) {
+      throw new Error('Invalid token list');
+    }
+
+    const tokensWithLogoUri = tokens.tokens.filter((token: any) => token.logoURI);
+
+    return tokensWithLogoUri.map((token: any) => {
+      return {
+        ...token,
+        logoURI: normalizeTokenLogoUri(token.logoURI)
+      };
+    });
+  } catch (e) {
+    console.warn(`Failed to fetch token list from ${tokenListUri}`);
+    return [];
+  }
+}
+
+const REPLACE_SIZE_REGEX: { pattern: RegExp; replacement: string }[] = [
+  {
+    pattern: /assets.coingecko.com\/coins\/images\/(\d+)\/(thumb|small)/,
+    replacement: 'assets.coingecko.com/coins/images/$1/large'
+  }
+];
+
+export function replaceSizePartsInImageUrls(list: AggregatedTokenList) {
+  return list.map(token => {
+    token.logoURI = REPLACE_SIZE_REGEX.reduce((acc, { pattern, replacement }) => {
+      return acc.replace(pattern, replacement);
+    }, token.logoURI);
+    return token;
+  });
+}
+
+export async function updateExpiredAggregatedTokenList() {
+  if (!isExpired()) {
+    return;
+  }
+
+  const list: AggregatedTokenList = [];
+
+  const uris = await fetchListUris();
+
+  await Promise.all(
+    uris.map(async tokenListUri => {
+      const tokens = await fetchTokens(tokenListUri);
+      list.push(...tokens);
+    })
+  );
+
+  aggregatedTokenList = replaceSizePartsInImageUrls(list);
+  lastUpdateTimestamp = Date.now();
+}
+
+export function findImageUrl(address: string, chainId: string) {
+  const checksum = getAddress(address);
+
+  const token = aggregatedTokenList.find(token => {
+    return token.chainId === parseInt(chainId) && getAddress(token.address) === checksum;
+  });
+
+  if (!token) {
+    throw new Error('Token not found');
+  }
+
+  return token.logoURI;
+}

src/index.ts

@@ -20,7 +20,7 @@ app.use(cors({ maxAge: 86400 }));
 app.use(compression());
 app.use('/', api);
 
-app.get('/', (req, res) => {
+app.get('/', (_req, res) => {
   const commit = process.env.COMMIT_HASH ?? undefined;
   res.json({ name, version, commit });
 });

src/resolvers/index.ts

@@ -10,6 +10,7 @@ import lens from './lens';
 import zapper from './zapper';
 import starknet from './starknet';
 import farcaster from './farcaster';
+import tokenlists from './tokenlists';
 
 export default {
   blockie,
@@ -25,5 +26,6 @@ export default {
   lens,
   zapper,
   starknet,
-  farcaster
+  farcaster,
+  tokenlists
 };

src/resolvers/tokenlists.ts

@@ -0,0 +1,16 @@
+import { resize } from '../utils';
+import { max } from '../constants.json';
+import { fetchHttpImage } from './utils';
+import { findImageUrl, updateExpiredAggregatedTokenList } from '../helpers/tokenlists';
+
+export default async function resolve(address: string, chainId: string) {
+  try {
+    await updateExpiredAggregatedTokenList();
+    const url = findImageUrl(address, chainId);
+    const image = await fetchHttpImage(url);
+
+    return await resize(image, max, max);
+  } catch (e) {
+    return false;
+  }
+}

test/e2e/api.test.ts

@@ -3,6 +3,7 @@ import redis from '../../src/helpers/redis';
 import { KEY_PREFIX } from '../../src/addressResolvers/cache';
 
 const HOST = `http://localhost:${process.env.PORT || 3003}`;
+const cUSDC_TOKEN_ADDRESS_ON_MAIN = '0x39AA39c021dfbaE8faC545936693aC917d5E7563';
 
 async function purge(): Promise<void> {
   if (!redis) return;
@@ -14,8 +15,20 @@ async function purge(): Promise<void> {
   transaction.exec();
 }
 
+// for token resolver, which needs a moment on first run
+// I think the tests need to return promises.
+jest.setTimeout(60_000);
+
 describe('E2E api', () => {
   describe('GET type/TYPE/ID', () => {
+    it('returns an image for tokenlists resolver', async () => {
+      const response = await axios.get(
+        `${HOST}/token/${cUSDC_TOKEN_ADDRESS_ON_MAIN}?resolver=tokenlists`
+      );
+      expect(response.status).toBe(200);
+      expect(response.headers['content-type']).toBe('image/webp');
+    });
+
     it.todo('returns a 500 status on invalid query');
 
     describe('when the image is not cached', () => {

test/unit/tokenlists.test.ts

@@ -0,0 +1,45 @@
+import { replaceSizePartsInImageUrls } from '../../src/helpers/tokenlists';
+
+test('replaceSizePartsInImageUrls should replace image size parts in URLs', () => {
+  const tokenList = [
+    {
+      chainId: 1,
+      address: '0x1234567890abcdef',
+      symbol: 'ABC',
+      name: 'Token ABC',
+      logoURI: 'https://assets.coingecko.com/coins/images/123/thumb',
+      decimals: 18
+    },
+    {
+      chainId: 1,
+      address: '0xabcdef1234567890',
+      symbol: 'DEF',
+      name: 'Token DEF',
+      logoURI: 'https://assets.coingecko.com/coins/images/456/small',
+      decimals: 18
+    }
+  ];
+
+  const expectedTokenList = [
+    {
+      chainId: 1,
+      address: '0x1234567890abcdef',
+      symbol: 'ABC',
+      name: 'Token ABC',
+      logoURI: 'https://assets.coingecko.com/coins/images/123/large',
+      decimals: 18
+    },
+    {
+      chainId: 1,
+      address: '0xabcdef1234567890',
+      symbol: 'DEF',
+      name: 'Token DEF',
+      logoURI: 'https://assets.coingecko.com/coins/images/456/large',
+      decimals: 18
+    }
+  ];
+
+  const result = replaceSizePartsInImageUrls(tokenList);
+
+  expect(result).toEqual(expectedTokenList);
+});