@uniswap/token-list-bridge-utils 2.10.0 → 2.12.0

package/src/constants/excludedTokens.test.ts

@@ -0,0 +1,124 @@
+import { isTokenExcluded, EXCLUDED_TOKENS } from './excludedTokens'
+import { ChainId } from './chainId'
+
+describe('excludedTokens', () => {
+  describe('isTokenExcluded', () => {
+    it('returns true for excluded tokens on Arbitrum', () => {
+      expect(
+        isTokenExcluded(
+          ChainId.ARBITRUM_ONE,
+          '0xfEb4DfC8C4Cf7Ed305bb08065D08eC6ee6728429'
+        )
+      ).toBe(true)
+    })
+
+    it('returns true for excluded tokens on Polygon', () => {
+      expect(
+        isTokenExcluded(
+          ChainId.POLYGON,
+          '0x553d3D295e0f695B9228246232eDF400ed3560B5'
+        )
+      ).toBe(true)
+    })
+
+    it('returns true for excluded tokens on Unichain', () => {
+      expect(
+        isTokenExcluded(
+          ChainId.UNICHAIN,
+          '0x89f7C0870794103744C8042630CC1C846a858E57'
+        )
+      ).toBe(true)
+    })
+
+    it('is case-insensitive for token addresses', () => {
+      expect(
+        isTokenExcluded(
+          ChainId.ARBITRUM_ONE,
+          '0xFEB4DFC8C4CF7ED305BB08065D08EC6EE6728429'
+        )
+      ).toBe(true)
+
+      expect(
+        isTokenExcluded(
+          ChainId.POLYGON,
+          '0X553D3D295E0F695B9228246232EDF400ED3560B5'
+        )
+      ).toBe(true)
+    })
+
+    it('returns false for non-excluded tokens', () => {
+      expect(
+        isTokenExcluded(
+          ChainId.ARBITRUM_ONE,
+          '0x0000000000000000000000000000000000000000'
+        )
+      ).toBe(false)
+
+      expect(
+        isTokenExcluded(
+          ChainId.POLYGON,
+          '0x0000000000000000000000000000000000000000'
+        )
+      ).toBe(false)
+    })
+
+    it('returns false for chains without exclusions', () => {
+      expect(
+        isTokenExcluded(
+          ChainId.OPTIMISM,
+          '0xfEb4DfC8C4Cf7Ed305bb08065D08eC6ee6728429'
+        )
+      ).toBe(false)
+
+      expect(
+        isTokenExcluded(
+          ChainId.BASE,
+          '0x553d3D295e0f695B9228246232eDF400ed3560B5'
+        )
+      ).toBe(false)
+    })
+
+    it('returns false when excluded token is checked against wrong chain', () => {
+      // Arbitrum excluded token checked on Polygon
+      expect(
+        isTokenExcluded(
+          ChainId.POLYGON,
+          '0xfEb4DfC8C4Cf7Ed305bb08065D08eC6ee6728429'
+        )
+      ).toBe(false)
+
+      // Polygon excluded token checked on Arbitrum
+      expect(
+        isTokenExcluded(
+          ChainId.ARBITRUM_ONE,
+          '0x553d3D295e0f695B9228246232eDF400ed3560B5'
+        )
+      ).toBe(false)
+    })
+  })
+
+  describe('EXCLUDED_TOKENS', () => {
+    it('contains the correct chains', () => {
+      expect(EXCLUDED_TOKENS[ChainId.ARBITRUM_ONE]).toBeDefined()
+      expect(EXCLUDED_TOKENS[ChainId.POLYGON]).toBeDefined()
+      expect(EXCLUDED_TOKENS[ChainId.UNICHAIN]).toBeDefined()
+    })
+
+    it('stores addresses in lowercase', () => {
+      const arbitrumExcluded = Array.from(EXCLUDED_TOKENS[ChainId.ARBITRUM_ONE])
+      expect(
+        arbitrumExcluded.every((addr) => addr === addr.toLowerCase())
+      ).toBe(true)
+
+      const polygonExcluded = Array.from(EXCLUDED_TOKENS[ChainId.POLYGON])
+      expect(polygonExcluded.every((addr) => addr === addr.toLowerCase())).toBe(
+        true
+      )
+
+      const unichainExcluded = Array.from(EXCLUDED_TOKENS[ChainId.UNICHAIN])
+      expect(
+        unichainExcluded.every((addr) => addr === addr.toLowerCase())
+      ).toBe(true)
+    })
+  })
+})

package/src/constants/excludedTokens.ts

@@ -0,0 +1,25 @@
+import { ChainId } from './chainId'
+
+/**
+ * Tokens to exclude from being added to the token list.
+ * Key: chainId, Value: Set of lowercase token addresses to exclude on that chain
+ */
+export const EXCLUDED_TOKENS: { [chainId: number]: Set<string> } = {
+  [ChainId.ARBITRUM_ONE]: new Set([
+    '0xfeb4dfc8c4cf7ed305bb08065d08ec6ee6728429',
+  ]),
+  [ChainId.POLYGON]: new Set(['0x553d3d295e0f695b9228246232edf400ed3560b5']),
+  [ChainId.UNICHAIN]: new Set(['0x89f7c0870794103744c8042630cc1c846a858e57']),
+}
+
+/**
+ * Check if a token address should be excluded on a given chain
+ */
+export function isTokenExcluded(
+  chainId: number,
+  tokenAddress: string
+): boolean {
+  const excludedSet = EXCLUDED_TOKENS[chainId]
+  if (!excludedSet) return false
+  return excludedSet.has(tokenAddress.toLowerCase())
+}

package/src/index.test.ts

@@ -1,4 +1,5 @@
-import { TokenInfo } from '@uniswap/token-lists'
+import { TokenInfo, TokenList } from '@uniswap/token-lists'
+import { Token } from '@uniswap/sdk-core'
 import { chainify, chainifyTokenList, mergeTokenLists } from '.'
 import { ChainId } from './constants/chainId'
 import {
@@ -457,3 +458,152 @@ describe(chainify, () => {
     ])
   })
 })
+
+describe('excluded tokens', () => {
+  it('excludes tokens from Arbitrum when specified in EXCLUDED_TOKENS', async () => {
+    // Use a token that has the excluded L2 address as its explicit bridgeInfo
+    const testTokenList: TokenList = {
+      name: 'Test Exclusion',
+      timestamp: new Date().toISOString(),
+      version: { major: 1, minor: 0, patch: 0 },
+      tokens: [
+        {
+          chainId: ChainId.MAINNET,
+          address: '0x0000000000000000000000000000000000000001',
+          name: 'Test Token',
+          symbol: 'TEST',
+          decimals: 18,
+          extensions: {
+            bridgeInfo: {
+              [ChainId.ARBITRUM_ONE]: {
+                tokenAddress: '0xfEb4DfC8C4Cf7Ed305bb08065D08eC6ee6728429', // excluded arbitrum address
+              },
+            },
+          },
+        },
+      ],
+    }
+
+    const chainified = await chainifyTokenList(
+      [ChainId.ARBITRUM_ONE],
+      testTokenList
+    )
+
+    // Should only contain mainnet token, not the Arbitrum L2 token
+    expect(chainified.tokens.length).toBe(1)
+    expect(chainified.tokens[0].chainId).toBe(ChainId.MAINNET)
+    // Should not have bridgeInfo for Arbitrum since L2 token is excluded
+    expect(chainified.tokens[0].extensions?.bridgeInfo).toBeUndefined()
+  })
+
+  it('excludes tokens from Polygon when specified in EXCLUDED_TOKENS', async () => {
+    // Use DAI which has a valid Polygon mapping
+    const testTokenList: TokenList = {
+      name: 'Test Polygon Exclusion',
+      timestamp: new Date().toISOString(),
+      version: { major: 1, minor: 0, patch: 0 },
+      tokens: [
+        {
+          chainId: ChainId.MAINNET,
+          address: '0x6B175474E89094C44Da98b954EedeAC495271d0F', // DAI
+          name: 'Dai Stablecoin',
+          symbol: 'DAI',
+          decimals: 18,
+          extensions: {
+            bridgeInfo: {
+              [ChainId.POLYGON]: {
+                tokenAddress: '0x553d3D295e0f695B9228246232eDF400ed3560B5', // excluded polygon address
+              },
+            },
+          },
+        },
+      ],
+    }
+
+    const chainified = await chainifyTokenList([ChainId.POLYGON], testTokenList)
+
+    // Should only contain mainnet token, not the Polygon L2 token
+    expect(chainified.tokens.length).toBe(1)
+    expect(chainified.tokens[0].chainId).toBe(ChainId.MAINNET)
+    // Should not have bridgeInfo for Polygon since the L2 token is excluded
+    expect(chainified.tokens[0].extensions?.bridgeInfo).toBeUndefined()
+  })
+
+  it('excludes tokens from Unichain when specified in EXCLUDED_TOKENS', async () => {
+    // Create a token list with the excluded Unichain token
+    const EXCLUDED_TOKEN_MAINNET = new Token(
+      ChainId.MAINNET,
+      '0x45804880de22913dafe09f4980848ece6ecbaf78', // PAX Gold - maps to excluded unichain token
+      18,
+      'PAXG',
+      'PAX Gold'
+    )
+
+    const testTokenList: TokenList = {
+      name: 'Test Unichain Exclusion',
+      timestamp: new Date().toISOString(),
+      version: { major: 1, minor: 0, patch: 0 },
+      tokens: [
+        {
+          chainId: ChainId.MAINNET,
+          address: EXCLUDED_TOKEN_MAINNET.address,
+          name: EXCLUDED_TOKEN_MAINNET.name!,
+          symbol: EXCLUDED_TOKEN_MAINNET.symbol!,
+          decimals: EXCLUDED_TOKEN_MAINNET.decimals,
+        },
+      ],
+    }
+
+    const chainified = await chainifyTokenList(
+      [ChainId.UNICHAIN],
+      testTokenList
+    )
+
+    // Should only contain mainnet token, not the Unichain L2 token
+    expect(chainified.tokens.length).toBe(1)
+    expect(chainified.tokens[0].chainId).toBe(ChainId.MAINNET)
+    expect(chainified.tokens[0].address.toLowerCase()).toBe(
+      EXCLUDED_TOKEN_MAINNET.address.toLowerCase()
+    )
+    // Should not have bridgeInfo for Unichain
+    expect(chainified.tokens[0].extensions?.bridgeInfo).toBeUndefined()
+  })
+
+  it('does not exclude tokens on non-excluded chains', async () => {
+    // Use the same mainnet address that maps to excluded Arbitrum token
+    // but chainify for Optimism instead
+    const TOKEN_MAINNET = new Token(
+      ChainId.MAINNET,
+      '0x8290333cef9e6d528dd5618fb97a76f268f3edd4',
+      18,
+      'ANKR',
+      'Ankr Network'
+    )
+
+    const testTokenList: TokenList = {
+      name: 'Test Non-Exclusion',
+      timestamp: new Date().toISOString(),
+      version: { major: 1, minor: 0, patch: 0 },
+      tokens: [
+        {
+          chainId: ChainId.MAINNET,
+          address: TOKEN_MAINNET.address,
+          name: TOKEN_MAINNET.name!,
+          symbol: TOKEN_MAINNET.symbol!,
+          decimals: TOKEN_MAINNET.decimals,
+        },
+      ],
+    }
+
+    const chainified = await chainifyTokenList(
+      [ChainId.OPTIMISM],
+      testTokenList
+    )
+
+    // May contain L2 tokens if valid mappings exist for Optimism
+    const mainnetToken = chainified.tokens.find(
+      (t) => t.chainId === ChainId.MAINNET
+    )
+    expect(mainnetToken).toBeDefined()
+  })
+})

package/src/index.ts

@@ -9,6 +9,8 @@ import {
 } from './utils'
 import { verifyExtensions } from './verify'
 
+export { EXCLUDED_TOKENS, isTokenExcluded } from './constants/excludedTokens'
+
 /**
  * Adds bridgeInfo to the given token list for Optimism, Polygon and Arbitrum.
  * @param l1TokenListOrPathOrUrl
@@ -28,6 +30,7 @@ export async function chainify(
     ChainId.BASE,
     ChainId.UNICHAIN,
     ChainId.SONEIUM,
+    ChainId.MONAD,
   ]
 
   const chainified = await chainifyTokenList(l2Chains, l1TokenListOrPathOrUrl)

package/src/local_mappings/monad.json

@@ -0,0 +1,22 @@
+{
+  "0xdac17f958d2ee523a2206206994597c13d831ec7": {
+    "childToken": "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+    "decimals": 6
+  },
+  "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599": {
+    "childToken": "0x0555E30da8f98308EdB960aa94C0Db47230d2B9c",
+    "decimals": 8
+  },
+  "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2": {
+    "childToken": "0xEE8c0E9f1BFFb4Eb878d8f15f368A02a35481242",
+    "decimals": 18
+  },
+  "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48": {
+    "childToken": "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
+    "decimals": 6
+  },
+  "0xd31a59c85ae9d8edefec411d448f90841571b89c": {
+    "childToken": "0xea17E5a9efEBf1477dB45082d67010E2245217f1",
+    "decimals": 9
+  }
+}

package/src/providers/MonadMappingProvider.ts

@@ -0,0 +1,11 @@
+import { MappingProvider } from './MappingProvider'
+import { MappedTokenData } from '../constants/types'
+import monadMappings from '../local_mappings/monad.json'
+
+// we use a local source of mappings for monad
+export class MonadMappingProvider implements MappingProvider {
+  async provide(): Promise<MappedTokenData> {
+    const tokens = monadMappings as MappedTokenData
+    return tokens
+  }
+}

package/src/providers/index.ts

@@ -5,6 +5,7 @@ import { OptimismMappingProvider } from './OptimismMappingProvider'
 import { PolygonMappingProvider } from './PolygonMappingProvider'
 import { BnbMappingProvider } from './BnbMappingProvider'
 import { UnichainMappingProvider } from './UnichainMappingProvider'
+import { MonadMappingProvider } from './MonadMappingProvider'
 import { TokenInfo, TokenList } from '@uniswap/token-lists'
 import { ethers } from 'ethers'
 import {
@@ -25,6 +26,7 @@ import { AvalancheMappingProvider } from './AvalancheMappingProvider'
 import { BaseMappingProvider } from './BaseMappingProvider'
 import { CeloMappingProvider } from './CeloMappingProvider'
 import { SoneiumMappingProvider } from './SoneiumMappingProvider'
+import { isTokenExcluded } from '../constants/excludedTokens'
 
 const web3 = new Web3()
 
@@ -39,6 +41,7 @@ const CHAINS_WITH_MAPPING_PROVIDERS = [
   ChainId.BASE,
   ChainId.UNICHAIN,
   ChainId.SONEIUM,
+  ChainId.MONAD,
 ]
 
 export async function buildList(
@@ -72,10 +75,17 @@ export async function buildList(
             chainId,
             chainIdToMappingsMap
           )
-          if (chainIdToChildTokenDetailsMap[chainId].childTokenValid) {
+          const childTokenAddress =
+            chainIdToChildTokenDetailsMap[chainId].childTokenAddress
+
+          // Only add bridgeInfo if child token is valid and not excluded
+          if (
+            chainIdToChildTokenDetailsMap[chainId].childTokenValid &&
+            childTokenAddress &&
+            !isTokenExcluded(chainId, childTokenAddress)
+          ) {
             l2MappingExtension.extensions.bridgeInfo[chainId] = {
-              tokenAddress:
-                chainIdToChildTokenDetailsMap[chainId].childTokenAddress,
+              tokenAddress: childTokenAddress,
             }
           }
         })
@@ -83,6 +93,16 @@ export async function buildList(
 
       // build the TokenInfo objects with bridgeInfo extension
       l2ChainIds.concat([ChainId.MAINNET]).forEach((chainId) => {
+        const tokenAddress =
+          chainId === ChainId.MAINNET
+            ? l1Token.address
+            : chainIdToChildTokenDetailsMap[chainId]?.childTokenAddress
+
+        // Skip if token is excluded on this chain
+        if (tokenAddress && isTokenExcluded(chainId, tokenAddress)) {
+          return
+        }
+
         if (
           chainId === ChainId.MAINNET ||
           chainIdToChildTokenDetailsMap[chainId].childTokenValid
@@ -166,6 +186,8 @@ function getMappingProvider(chainId: ChainId, l1TokenList: TokenList) {
       return new UnichainMappingProvider()
     case ChainId.SONEIUM:
       return new SoneiumMappingProvider()
+    case ChainId.MONAD:
+      return new MonadMappingProvider()
     default:
       throw new Error(`Chain ${chainId} not supported for fetching mappings.`)
   }
@@ -233,7 +255,7 @@ async function getChildTokenDetails(
       : undefined
     const childTokenValid = Boolean(
       childTokenAddress &&
-        (chainId === ChainId.UNICHAIN // barring a unichain rpc url, we skip the contract call. Since we're using a manually curated list of tokens, we can assume they exist.
+        (chainId === ChainId.UNICHAIN || chainId === ChainId.MONAD // barring a unichain/monad rpc url, we skip the contract call. Since we're using a manually curated list of tokens, we can assume they exist.
           ? true
           : await hasExistingTokenContract(childTokenAddress, chainId))
     )

package/src/utils.ts

@@ -97,7 +97,7 @@ export function getRpcUrl(chainId: ChainId): string {
     case ChainId.MAINNET:
       return 'https://ethereum-rpc.publicnode.com'
     case ChainId.OPTIMISM:
-      return 'https://rpc.ankr.com/optimism' // seems to have higher rate limit than https://mainnet.optimism.io/
+      return 'https://mainnet.optimism.io'
     case ChainId.OPTIMISTIC_KOVAN:
       return 'https://kovan.optimism.io'
     case ChainId.ARBITRUM_ONE: