@uniswap/token-list-bridge-utils 2.7.0 → 2.9.0

package/src/providers/ArbitrumMappingProvider.test.ts

@@ -0,0 +1,123 @@
+import { ArbitrumMappingProvider } from './ArbitrumMappingProvider'
+import { getL2TokenAddressesFromL1 } from '../arbitrum/gateway'
+import { getNetworkConfig } from '../arbitrum/instantiate_bridge'
+import { TokenList } from '@uniswap/token-lists'
+
+jest.mock('../arbitrum/gateway')
+jest.mock('../arbitrum/instantiate_bridge')
+
+describe('ArbitrumMappingProvider', () => {
+  const mockL1TokenList: TokenList = {
+    name: 'Test Token List',
+    timestamp: '2024-01-01T00:00:00.000Z',
+    version: { major: 1, minor: 0, patch: 0 },
+    tokens: [
+      {
+        address: '0x1234',
+        chainId: 1,
+        decimals: 18,
+        name: 'Token1',
+        symbol: 'TK1',
+      },
+      {
+        address: '0x5678',
+        chainId: 1,
+        decimals: 18,
+        name: 'Token2',
+        symbol: 'TK2',
+      },
+      {
+        address: '0x9abc',
+        chainId: 1,
+        decimals: 18,
+        name: 'Token3',
+        symbol: 'TK3',
+      },
+    ],
+  }
+
+  const mockNetworkConfig = {
+    l1: {
+      multiCaller: 'mockMultiCaller',
+    },
+    l2: {
+      network: {
+        tokenBridge: {
+          l1GatewayRouter: '0xgatewayAddress',
+        },
+      },
+    },
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    ;(getNetworkConfig as jest.Mock).mockResolvedValue(mockNetworkConfig)
+  })
+
+  it('should correctly map L1 tokens to L2 addresses in batches', async () => {
+    const mockL2Addresses = ['0x1234L2', '0x5678L2', '0x9abcL2']
+    ;(getL2TokenAddressesFromL1 as jest.Mock).mockResolvedValue(mockL2Addresses)
+
+    const provider = new ArbitrumMappingProvider(mockL1TokenList)
+    const result = await provider.provide()
+
+    expect(result).toEqual({
+      '0x1234': '0x1234L2',
+      '0x5678': '0x5678L2',
+      '0x9abc': '0x9abcL2',
+    })
+
+    expect(getL2TokenAddressesFromL1).toHaveBeenCalledWith(
+      ['0x1234', '0x5678', '0x9abc'].map((addr) => addr.toLowerCase()),
+      'mockMultiCaller',
+      '0xgatewayAddress'
+    )
+  })
+
+  it('should handle undefined L2 addresses correctly', async () => {
+    const mockL2Addresses = ['0x1234L2', undefined, '0x9abcL2']
+    ;(getL2TokenAddressesFromL1 as jest.Mock).mockImplementation(
+      (addresses) => {
+        // Return only the defined addresses from our mock data
+        return mockL2Addresses.filter((addr) => addr !== undefined)
+      }
+    )
+
+    const provider = new ArbitrumMappingProvider(mockL1TokenList)
+    const result = await provider.provide()
+
+    // Our implementation filters out undefined values before adding to batches array,
+    // so the indexes will shift. The final mapping will have undefined for any
+    // addresses that don't have a corresponding L2 address in order
+    expect(result).toEqual({
+      '0x1234': '0x1234L2',
+      '0x5678': '0x9abcL2', // Gets the next available L2 address
+      '0x9abc': undefined, // No more L2 addresses available
+    })
+  })
+
+  it('should process tokens in batches of 100', async () => {
+    // Create a token list with 150 tokens
+    const largeTokenList: TokenList = {
+      ...mockL1TokenList,
+      tokens: Array.from({ length: 150 }, (_, i) => ({
+        address: `0x${i}`,
+        chainId: 1,
+        decimals: 18,
+        name: `Token${i}`,
+        symbol: `TK${i}`,
+      })),
+    }
+
+    const provider = new ArbitrumMappingProvider(largeTokenList)
+    await provider.provide()
+
+    // Verify that getL2TokenAddressesFromL1 was called twice
+    // Once with 100 tokens and once with 50 tokens
+    expect(getL2TokenAddressesFromL1).toHaveBeenCalledTimes(2)
+    const firstCall = (getL2TokenAddressesFromL1 as jest.Mock).mock.calls[0][0]
+    const secondCall = (getL2TokenAddressesFromL1 as jest.Mock).mock.calls[1][0]
+    expect(firstCall.length).toBe(100)
+    expect(secondCall.length).toBe(50)
+  })
+})

package/src/providers/ArbitrumMappingProvider.ts

@@ -23,14 +23,24 @@ export class ArbitrumMappingProvider implements MappingProvider {
       token.address.toLowerCase()
     )
 
-    const l2AddressesFromL1 = await getL2TokenAddressesFromL1(
-      tokenAddresses,
-      l1.multiCaller,
-      l2.network.tokenBridge.l1GatewayRouter
-    )
+    // batching calls to avoid rpc response size limits
+    const batchSize = 100
+    const batches: string[] = []
+    for (let i = 0; i < tokenAddresses.length; i += batchSize) {
+      const batch = tokenAddresses.slice(i, i + batchSize)
+      const batchResults = await getL2TokenAddressesFromL1(
+        batch,
+        l1.multiCaller,
+        l2.network.tokenBridge.l1GatewayRouter
+      )
+      const filteredResults = batchResults.filter(
+        (addr): addr is string => addr !== undefined
+      )
+      batches.push(...filteredResults)
+    }
 
     tokens = tokenAddresses.reduce(
-      (obj, key, index) => ({ ...obj, [key]: l2AddressesFromL1[index] }),
+      (obj, key, index) => ({ ...obj, [key]: batches[index] }),
       {}
     )
 

package/src/providers/SoneiumMappingProvider.ts

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

package/src/providers/index.ts

@@ -24,6 +24,7 @@ import {
 import { AvalancheMappingProvider } from './AvalancheMappingProvider'
 import { BaseMappingProvider } from './BaseMappingProvider'
 import { CeloMappingProvider } from './CeloMappingProvider'
+import { SoneiumMappingProvider } from './SoneiumMappingProvider'
 
 const web3 = new Web3()
 
@@ -37,6 +38,7 @@ const CHAINS_WITH_MAPPING_PROVIDERS = [
   ChainId.CELO,
   ChainId.BASE,
   ChainId.UNICHAIN,
+  ChainId.SONEIUM,
 ]
 
 export async function buildList(
@@ -162,6 +164,8 @@ function getMappingProvider(chainId: ChainId, l1TokenList: TokenList) {
       return new BaseMappingProvider()
     case ChainId.UNICHAIN:
       return new UnichainMappingProvider()
+    case ChainId.SONEIUM:
+      return new SoneiumMappingProvider()
     default:
       throw new Error(`Chain ${chainId} not supported for fetching mappings.`)
   }

package/src/utils.ts

@@ -118,6 +118,8 @@ export function getRpcUrl(chainId: ChainId): string {
       return 'https://alfajores-forno.celo-testnet.org/'
     case ChainId.BASE:
       return 'https://mainnet.base.org'
+    case ChainId.SONEIUM:
+      return 'https://soneium.drpc.org'
     default:
   }
   throw new Error('Unsupported ChainId')