@uniswap/token-list-bridge-utils 2.10.0 → 2.11.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

package/src/providers/index.ts

@@ -25,6 +25,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()
 
@@ -72,10 +73,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 +91,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