@uniswap/token-list-bridge-utils 2.0.0 → 2.2.0

package/src/arbitrum/instantiate_bridge.ts

@@ -3,6 +3,14 @@ import { providers } from 'ethers'
 
 const networkID = 42161
 
+const l2Rpc = (chainId: number) => {
+  if (chainId === 42161) return 'https://arb1.arbitrum.io/rpc'
+  else if (chainId === 421611) return 'https://rinkeby.arbitrum.io/rpc'
+  else if (chainId === 42170) return 'https://nova.arbitrum.io/rpc'
+  else if (chainId === 421613) return 'https://goerli-rollup.arbitrum.io/rpc'
+  throw new Error('No L2 RPC detected')
+}
+
 // ref: https://github.com/OffchainLabs/arb-token-lists/blob/master/src/lib/instantiate_bridge.ts
 export const getNetworkConfig = async () => {
   const { getL1Network, getL2Network, MultiCaller } = await import(
@@ -11,8 +19,8 @@ export const getNetworkConfig = async () => {
   const l2Network = await getL2Network(networkID)
   const l1Network = await getL1Network(l2Network.partnerChainID)
 
-  const arbProvider = new providers.JsonRpcProvider(l2Network.rpcURL)
-  const ethProvider = new providers.JsonRpcProvider(l1Network.rpcURL)
+  const arbProvider = new providers.JsonRpcProvider(l2Rpc(l2Network.chainID))
+  const ethProvider = new providers.JsonRpcProvider(process.env.MAINNET_RPC)
 
   const l1MultiCaller = await MultiCaller.fromProvider(ethProvider)
   const l2MultiCaller = await MultiCaller.fromProvider(arbProvider)

package/src/constants/chainId.ts

@@ -15,4 +15,7 @@ export enum ChainId {
   BNB = 56,
 
   AVALANCHE = 43114,
+
+  BASE = 8453,
+  BASE_GOERLI = 84531,
 }

package/src/constants/tokens.ts

@@ -1,6 +1,46 @@
 import { Token } from '@uniswap/sdk-core'
 import { ChainId } from './chainId'
 
+export const COINBASE_WRAPPED_STAKED_ETH = new Token(
+  ChainId.MAINNET,
+  '0xbe9895146f7af43049ca1c1ae358b0541ea49704',
+  18,
+  'cbETH',
+  'Coinbase Wrapped Staked ETH'
+)
+
+export const COINBASE_WRAPPED_STAKED_ETH_BASE_GOERLI = new Token(
+  ChainId.BASE_GOERLI,
+  '0x4fC531f8Ae7A7808E0dccCA08F1e3c7694582950',
+  18,
+  'cbETH',
+  'Coinbase Wrapped Staked ETH'
+)
+
+export const COINBASE_WRAPPED_STAKED_ETH_BASE = new Token(
+  ChainId.BASE,
+  '0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22',
+  18,
+  'cbETH',
+  'Coinbase Wrapped Staked ETH'
+)
+
+export const COINBASE_WRAPPED_STAKED_ETH_ARBITRUM_ONE = new Token(
+  ChainId.ARBITRUM_ONE,
+  '0x1DEBd73E752bEaF79865Fd6446b0c970EaE7732f',
+  18,
+  'cbETH',
+  'Coinbase Wrapped Staked ETH'
+)
+
+export const COINBASE_WRAPPED_STAKED_ETH_OPTIMISM = new Token(
+  ChainId.OPTIMISM,
+  '0xadDb6A0412DE1BA0F936DCaeb8Aaa24578dcF3B2',
+  18,
+  'cbETH',
+  'Coinbase Wrapped Staked ETH'
+)
+
 export const DAI = new Token(
   ChainId.MAINNET,
   '0x6B175474E89094C44Da98b954EedeAC495271d0F',
@@ -46,6 +86,22 @@ export const DAI_AVALANCHE = new Token(
   'DAI.e'
 )
 
+export const DAI_BASE = new Token(
+  ChainId.BASE,
+  '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+  18,
+  'DAI',
+  'Dai Stablecoin'
+)
+
+export const DAI_BASE_GOERLI = new Token(
+  ChainId.BASE_GOERLI,
+  '0x174956bDfbCEb6e53089297cce4fE2825E58d92C',
+  18,
+  'DAI',
+  'Dai Stablecoin'
+)
+
 export const USDT = new Token(
   ChainId.MAINNET,
   '0xdAC17F958D2ee523a2206206994597C13D831ec7',

package/src/fixtures/index.ts

@@ -10,6 +10,13 @@ import {
   DAI_POLYGON,
   USDT,
   USDT_BNB,
+  COINBASE_WRAPPED_STAKED_ETH,
+  COINBASE_WRAPPED_STAKED_ETH_BASE_GOERLI,
+  COINBASE_WRAPPED_STAKED_ETH_ARBITRUM_ONE,
+  COINBASE_WRAPPED_STAKED_ETH_BASE,
+  DAI_BASE_GOERLI,
+  COINBASE_WRAPPED_STAKED_ETH_OPTIMISM,
+  DAI_BASE,
 } from '../constants/tokens'
 import { compareTokenInfos } from '../utils'
 
@@ -17,15 +24,22 @@ export const Tokens: Partial<Record<ChainId, Record<string, TokenInfo>>> = {
   [ChainId.MAINNET]: {
     DAI: tokenToTokenInfo(DAI),
     USDT: tokenToTokenInfo(USDT),
+    COINBASE_WRAPPED_STAKED_ETH: tokenToTokenInfo(COINBASE_WRAPPED_STAKED_ETH),
   },
   [ChainId.ARBITRUM_ONE]: {
     DAI: tokenToTokenInfo(DAI_ARBITRUM_ONE),
+    COINBASE_WRAPPED_STAKED_ETH: tokenToTokenInfo(
+      COINBASE_WRAPPED_STAKED_ETH_ARBITRUM_ONE
+    ),
   },
   [ChainId.POLYGON]: {
     DAI: tokenToTokenInfo(DAI_POLYGON),
   },
   [ChainId.OPTIMISM]: {
     DAI: tokenToTokenInfo(DAI_OPTIMISM),
+    COINBASE_WRAPPED_STAKED_ETH: tokenToTokenInfo(
+      COINBASE_WRAPPED_STAKED_ETH_OPTIMISM
+    ),
   },
   [ChainId.BNB]: {
     DAI: tokenToTokenInfo(DAI_BNB),
@@ -34,6 +48,18 @@ export const Tokens: Partial<Record<ChainId, Record<string, TokenInfo>>> = {
   [ChainId.AVALANCHE]: {
     DAI: tokenToTokenInfo(DAI_AVALANCHE),
   },
+  [ChainId.BASE]: {
+    DAI: tokenToTokenInfo(DAI_BASE),
+    COINBASE_WRAPPED_STAKED_ETH: tokenToTokenInfo(
+      COINBASE_WRAPPED_STAKED_ETH_BASE
+    ),
+  },
+  [ChainId.BASE_GOERLI]: {
+    DAI: tokenToTokenInfo(DAI_BASE_GOERLI),
+    COINBASE_WRAPPED_STAKED_ETH: tokenToTokenInfo(
+      COINBASE_WRAPPED_STAKED_ETH_BASE_GOERLI
+    ),
+  },
 }
 
 export const sampleL1TokenList: TokenList = {
@@ -58,6 +84,17 @@ export const sampleL1TokenList_2: TokenList = {
   tokens: [Tokens[ChainId.MAINNET]!.USDT],
 }
 
+export const sampleL1TokenList_3: TokenList = {
+  name: 'Sample_3',
+  timestamp: new Date(1646146610).toISOString(),
+  version: {
+    major: 1,
+    minor: 0,
+    patch: 0,
+  },
+  tokens: [Tokens[ChainId.MAINNET]!.COINBASE_WRAPPED_STAKED_ETH],
+}
+
 export const arbBridgeL2Address = '0x467194771dae2967aef3ecbedd3bf9a310c76c65'
 export const arbBridgeL1Address = '0xd3b5b60020504bc3489d6949d545893982ba3011'
 
@@ -199,6 +236,62 @@ export const bnbedSampleTokenList_2 = {
   ].sort(compareTokenInfos),
 }
 
+export const baseGoerliSampleTokenList_3 = {
+  ...sampleL1TokenList_3,
+  name: 'Base Goerli Sample_3',
+  tokens: [
+    {
+      ...Tokens[ChainId.BASE_GOERLI]!.COINBASE_WRAPPED_STAKED_ETH,
+      extensions: {
+        bridgeInfo: {
+          [ChainId.MAINNET]: {
+            tokenAddress: COINBASE_WRAPPED_STAKED_ETH.address,
+          },
+        },
+      },
+    } as unknown as TokenInfo,
+    {
+      ...(Tokens[ChainId.MAINNET]!
+        .COINBASE_WRAPPED_STAKED_ETH as unknown as TokenInfo),
+      extensions: {
+        bridgeInfo: {
+          [ChainId.BASE_GOERLI]: {
+            tokenAddress: COINBASE_WRAPPED_STAKED_ETH_BASE_GOERLI.address,
+          },
+        },
+      },
+    } as unknown as TokenInfo,
+  ].sort(compareTokenInfos),
+}
+
+export const baseSampleTokenList_3 = {
+  ...sampleL1TokenList_3,
+  name: 'Base Sample_3',
+  tokens: [
+    {
+      ...Tokens[ChainId.BASE]!.COINBASE_WRAPPED_STAKED_ETH,
+      extensions: {
+        bridgeInfo: {
+          [ChainId.MAINNET]: {
+            tokenAddress: COINBASE_WRAPPED_STAKED_ETH.address,
+          },
+        },
+      },
+    } as unknown as TokenInfo,
+    {
+      ...(Tokens[ChainId.MAINNET]!
+        .COINBASE_WRAPPED_STAKED_ETH as unknown as TokenInfo),
+      extensions: {
+        bridgeInfo: {
+          [ChainId.BASE]: {
+            tokenAddress: COINBASE_WRAPPED_STAKED_ETH_BASE.address,
+          },
+        },
+      },
+    } as unknown as TokenInfo,
+  ].sort(compareTokenInfos),
+}
+
 export const optimizedSampleTokenList = {
   ...sampleL1TokenList,
   name: 'Optimized Sample',

package/src/index.test.ts

@@ -2,9 +2,16 @@ import { TokenInfo } from '@uniswap/token-lists'
 import { chainify, chainifyTokenList, mergeTokenLists } from '.'
 import { ChainId } from './constants/chainId'
 import {
+  COINBASE_WRAPPED_STAKED_ETH,
+  COINBASE_WRAPPED_STAKED_ETH_ARBITRUM_ONE,
+  COINBASE_WRAPPED_STAKED_ETH_BASE,
+  COINBASE_WRAPPED_STAKED_ETH_BASE_GOERLI,
+  COINBASE_WRAPPED_STAKED_ETH_OPTIMISM,
   DAI,
   DAI_ARBITRUM_ONE,
   DAI_AVALANCHE,
+  DAI_BASE,
+  DAI_BASE_GOERLI,
   DAI_BNB,
   DAI_OPTIMISM,
   DAI_POLYGON,
@@ -19,6 +26,9 @@ import {
   sampleL1TokenList_2,
   bnbedSampleTokenList_2,
   avalanchedSampleTokenList,
+  sampleL1TokenList_3,
+  baseGoerliSampleTokenList_3,
+  baseSampleTokenList_3,
 } from './fixtures'
 
 jest.setTimeout(15000)
@@ -136,6 +146,41 @@ it('outputs bnb list correctly with different decimals', async () => {
   )
 })
 
+it('outputs base goerli list correctly', async () => {
+  const tokenList = await chainifyTokenList(
+    [ChainId.BASE_GOERLI],
+    sampleL1TokenList_3
+  )
+  expect(tokenList).toBeDefined()
+  expect(tokenList?.version).toEqual(baseGoerliSampleTokenList_3.version)
+  expect(
+    tokenList?.tokens.map((t) => [t.address, t.chainId, t.extensions])
+  ).toEqual(
+    // ignores other metadata
+    baseGoerliSampleTokenList_3.tokens.map((t) => [
+      t.address,
+      t.chainId,
+      t.extensions,
+    ])
+  )
+})
+
+it('outputs base list correctly', async () => {
+  const tokenList = await chainifyTokenList([ChainId.BASE], sampleL1TokenList_3)
+  expect(tokenList).toBeDefined()
+  expect(tokenList?.version).toEqual(baseSampleTokenList_3.version)
+  expect(
+    tokenList?.tokens.map((t) => [t.address, t.chainId, t.extensions])
+  ).toEqual(
+    // ignores other metadata
+    baseSampleTokenList_3.tokens.map((t) => [
+      t.address,
+      t.chainId,
+      t.extensions,
+    ])
+  )
+})
+
 describe(mergeTokenLists, () => {
   it('correctly deduplicates', () => {
     const merged = mergeTokenLists(sampleL1TokenList, sampleL1TokenList)
@@ -256,6 +301,12 @@ describe(chainify, () => {
               // destBridgeAddress: arbBridgeL2Address,
               // originBridgeAddress: arbBridgeL1Address,
             },
+            [ChainId.BASE]: {
+              tokenAddress: DAI_BASE.address,
+            },
+            [ChainId.BASE_GOERLI]: {
+              tokenAddress: DAI_BASE_GOERLI.address,
+            },
           },
         },
       },
@@ -290,6 +341,16 @@ describe(chainify, () => {
           },
         },
       },
+      {
+        ...Tokens[ChainId.BASE]!.DAI,
+        extensions: {
+          bridgeInfo: {
+            [ChainId.MAINNET]: {
+              tokenAddress: DAI.address,
+            },
+          },
+        },
+      },
       {
         ...Tokens[ChainId.ARBITRUM_ONE]!.DAI,
         extensions: {
@@ -315,6 +376,86 @@ describe(chainify, () => {
           },
         },
       },
+      {
+        ...Tokens[ChainId.BASE_GOERLI]!.DAI,
+        extensions: {
+          bridgeInfo: {
+            [ChainId.MAINNET]: {
+              tokenAddress: DAI.address,
+            },
+          },
+        },
+      },
+    ])
+  })
+
+  it('provides bridge extensions for base list', async () => {
+    const chainified = await chainify(sampleL1TokenList_3)
+
+    expect(chainified.tokens).toEqual([
+      {
+        ...Tokens[ChainId.MAINNET]!.COINBASE_WRAPPED_STAKED_ETH,
+        extensions: {
+          bridgeInfo: {
+            [ChainId.OPTIMISM]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH_OPTIMISM.address,
+            },
+            [ChainId.BASE]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH_BASE.address,
+            },
+            [ChainId.BASE_GOERLI]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH_BASE_GOERLI.address,
+            },
+            [ChainId.ARBITRUM_ONE]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH_ARBITRUM_ONE.address,
+            },
+          },
+        },
+      },
+      {
+        ...Tokens[ChainId.OPTIMISM]!.COINBASE_WRAPPED_STAKED_ETH,
+        name: 'Coinbase Wrapped Staked ETH',
+        extensions: {
+          bridgeInfo: {
+            [ChainId.MAINNET]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH.address,
+            },
+          },
+        },
+      },
+      {
+        ...Tokens[ChainId.BASE]!.COINBASE_WRAPPED_STAKED_ETH,
+        name: 'Coinbase Wrapped Staked ETH',
+        extensions: {
+          bridgeInfo: {
+            [ChainId.MAINNET]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH.address,
+            },
+          },
+        },
+      },
+      {
+        ...Tokens[ChainId.ARBITRUM_ONE]!.COINBASE_WRAPPED_STAKED_ETH,
+        name: 'Coinbase Wrapped Staked ETH',
+        extensions: {
+          bridgeInfo: {
+            [ChainId.MAINNET]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH.address,
+            },
+          },
+        },
+      },
+      {
+        ...Tokens[ChainId.BASE_GOERLI]!.COINBASE_WRAPPED_STAKED_ETH,
+        name: 'Coinbase Wrapped Staked ETH',
+        extensions: {
+          bridgeInfo: {
+            [ChainId.MAINNET]: {
+              tokenAddress: COINBASE_WRAPPED_STAKED_ETH.address,
+            },
+          },
+        },
+      },
     ])
   })
 })

package/src/index.ts

@@ -25,13 +25,17 @@ export async function chainify(
     ChainId.CELO,
     ChainId.BNB,
     ChainId.AVALANCHE,
+    ChainId.BASE,
+    ChainId.BASE_GOERLI,
   ]
 
   const chainified = await chainifyTokenList(l2Chains, l1TokenListOrPathOrUrl)
-  return mergeTokenLists(
+  const merged = mergeTokenLists(
     l1TokenList, // providing l1 first to make sure duplicated tokens resolve to this list
     chainified
   )
+
+  return merged
 }
 
 /**
@@ -72,7 +76,10 @@ export function mergeTokenLists(
     }
 
     const merged = merge(group[0], group[1])
-    if (merged.extensions?.bridgeInfo) {
+    if (
+      merged.extensions?.bridgeInfo &&
+      typeof merged.extensions.bridgeInfo === 'object'
+    ) {
       // remove reference to self-chain from merge
       delete merged.extensions.bridgeInfo[merged.chainId]
     }

package/src/providers/BaseGoerliMappingProvider.ts

@@ -0,0 +1,43 @@
+import { MappingProvider } from './MappingProvider'
+import { ChainId } from '../constants/chainId'
+import { getTokenList } from '../utils'
+import { GenericMappedTokenData } from '../constants/types'
+
+const baseGoerliTokenListURL =
+  'https://raw.githubusercontent.com/' +
+  'ethereum-optimism/ethereum-optimism.github.io/master/optimism.tokenlist.json'
+
+/**
+ * The Base Goerli mapping (linked above) is manually maintained by the Coinbase team
+ * in this repository: https://github.com/ethereum-optimism/ethereum-optimism.github.io.
+ */
+export class BaseGoerliMappingProvider implements MappingProvider {
+  async provide(): Promise<GenericMappedTokenData> {
+    const tokens: { [key: string]: string | undefined } = {}
+
+    let allTokens = await getTokenList(baseGoerliTokenListURL)
+
+    let opTokenId_baseGoerliAddressMap: Record<string, string> = {}
+    allTokens.tokens.forEach((token) => {
+      if (token.chainId === ChainId.BASE_GOERLI) {
+        if (typeof token.extensions?.opTokenId === 'string') {
+          opTokenId_baseGoerliAddressMap[token.extensions.opTokenId] =
+            token.address
+        }
+      }
+    })
+
+    allTokens.tokens.forEach((token) => {
+      if (
+        token.chainId === ChainId.MAINNET &&
+        typeof token.extensions?.opTokenId === 'string' &&
+        token.extensions!.opTokenId in opTokenId_baseGoerliAddressMap
+      ) {
+        tokens[token.address.toLowerCase()] =
+          opTokenId_baseGoerliAddressMap[token.extensions!.opTokenId]
+      }
+    })
+
+    return tokens
+  }
+}

package/src/providers/BaseMappingProvider.ts

@@ -0,0 +1,42 @@
+import { MappingProvider } from './MappingProvider'
+import { ChainId } from '../constants/chainId'
+import { getTokenList } from '../utils'
+import { GenericMappedTokenData } from '../constants/types'
+
+const baseGoerliTokenListURL =
+  'https://raw.githubusercontent.com/' +
+  'ethereum-optimism/ethereum-optimism.github.io/master/optimism.tokenlist.json'
+
+/**
+ * The Base mapping (linked above) is manually maintained by the Coinbase team
+ * in this repository: https://github.com/ethereum-optimism/ethereum-optimism.github.io.
+ */
+export class BaseMappingProvider implements MappingProvider {
+  async provide(): Promise<GenericMappedTokenData> {
+    const tokens: { [key: string]: string | undefined } = {}
+
+    let allTokens = await getTokenList(baseGoerliTokenListURL)
+
+    let opTokenId_baseAddressMap: Record<string, string> = {}
+    allTokens.tokens.forEach((token) => {
+      if (token.chainId === ChainId.BASE) {
+        if (typeof token.extensions?.opTokenId === 'string') {
+          opTokenId_baseAddressMap[token.extensions.opTokenId] = token.address
+        }
+      }
+    })
+
+    allTokens.tokens.forEach((token) => {
+      if (
+        token.chainId === ChainId.MAINNET &&
+        typeof token.extensions?.opTokenId === 'string' &&
+        token.extensions!.opTokenId in opTokenId_baseAddressMap
+      ) {
+        tokens[token.address.toLowerCase()] =
+          opTokenId_baseAddressMap[token.extensions!.opTokenId]
+      }
+    })
+
+    return tokens
+  }
+}

package/src/providers/OptimismMappingProvider.ts

@@ -5,7 +5,7 @@ import { GenericMappedTokenData } from '../constants/types'
 
 const optimismTokenListURL =
   'https://raw.githubusercontent.com/' +
-  'ethereum-optimism/ethereum-optimism.github.io/2138386277e4156d159615d1840882cecc398437/optimism.tokenlist.json'
+  'ethereum-optimism/ethereum-optimism.github.io/master/optimism.tokenlist.json'
 
 /**
  * The Optimism L2 mapping (linked above) is manually maintained by the Optimism team.
@@ -16,14 +16,27 @@ export class OptimismMappingProvider implements MappingProvider {
   async provide(): Promise<GenericMappedTokenData> {
     const tokens: { [key: string]: string | undefined } = {}
 
-    let optimismTokens = await getTokenList(optimismTokenListURL)
+    let allTokens = await getTokenList(optimismTokenListURL)
 
-    for (const token of optimismTokens.tokens) {
-      if (token.chainId === ChainId.MAINNET) {
+    let opTokenId_baseAddressMap: Record<string, string> = {}
+    allTokens.tokens.forEach((token) => {
+      if (token.chainId === ChainId.OPTIMISM) {
+        if (typeof token.extensions?.opTokenId === 'string') {
+          opTokenId_baseAddressMap[token.extensions.opTokenId] = token.address
+        }
+      }
+    })
+
+    allTokens.tokens.forEach((token) => {
+      if (
+        token.chainId === ChainId.MAINNET &&
+        typeof token.extensions?.opTokenId === 'string' &&
+        token.extensions!.opTokenId in opTokenId_baseAddressMap
+      ) {
         tokens[token.address.toLowerCase()] =
-          token?.extensions?.bridgeInfo![ChainId.OPTIMISM].tokenAddress
+          opTokenId_baseAddressMap[token.extensions!.opTokenId]
       }
-    }
+    })
 
     return tokens
   }

package/src/providers/index.ts

@@ -21,6 +21,8 @@ import {
   MappedToken,
 } from '../constants/types'
 import { AvalancheMappingProvider } from './AvalancheMappingProvider'
+import { BaseGoerliMappingProvider } from './BaseGoerliMappingProvider'
+import { BaseMappingProvider } from './BaseMappingProvider'
 
 const web3 = new Web3()
 
@@ -31,6 +33,8 @@ const CHAINS_WITH_MAPPING_PROVIDERS = [
   ChainId.OPTIMISM,
   ChainId.BNB,
   ChainId.AVALANCHE,
+  ChainId.BASE,
+  ChainId.BASE_GOERLI,
 ]
 
 export async function buildList(
@@ -53,7 +57,7 @@ export async function buildList(
       } = {}
       const l2MappingExtension = {
         extensions: {
-          bridgeInfo: {},
+          bridgeInfo: {} as any,
         },
       }
       // build out the extensions.bridgeInfo data containing mappings for each L2 chain
@@ -131,7 +135,7 @@ async function hasExistingTokenContract(address: string, chainId: ChainId) {
   try {
     const contract: Contract = new web3.eth.Contract(ERC20Abi, address)
     await getTokenSymbolFromContract(contract)
-  } catch {
+  } catch (e) {
     return false
   }
 
@@ -150,6 +154,10 @@ function getMappingProvider(chainId: ChainId, l1TokenList: TokenList) {
       return new BnbMappingProvider()
     case ChainId.AVALANCHE:
       return new AvalancheMappingProvider()
+    case ChainId.BASE:
+      return new BaseMappingProvider()
+    case ChainId.BASE_GOERLI:
+      return new BaseGoerliMappingProvider()
     default:
       throw new Error(`Chain ${chainId} not supported for fetching mappings.`)
   }
@@ -193,8 +201,14 @@ async function getChildTokenDetails(
   childTokenAddress: string | undefined
   decimals?: number | undefined
 }> {
-  const existingMapping: undefined | string =
-    l1Token?.extensions?.bridgeInfo?.[chainId]?.tokenAddress
+  const bridgeInfo = l1Token?.extensions?.bridgeInfo
+  let existingMapping: undefined | string
+  if (bridgeInfo && typeof bridgeInfo === 'object') {
+    const bridgeInfoForChain = bridgeInfo[chainId]
+    if (bridgeInfoForChain && typeof bridgeInfoForChain === 'object') {
+      existingMapping = bridgeInfoForChain.tokenAddress as string
+    }
+  }
   // use the externally fetched mappings if manual entry doesn't exist for the token/chain mapping
   // and the given chain is supported for fetching mappings
   if (
@@ -217,7 +231,6 @@ async function getChildTokenDetails(
       childToken && (chainId === ChainId.BNB || chainId === ChainId.AVALANCHE)
         ? (childToken as MappedToken).decimals
         : undefined
-
     return {
       childTokenValid: childTokenValid,
       childTokenAddress: childTokenAddress,

package/src/utils.ts

@@ -111,7 +111,11 @@ export function getRpcUrl(chainId: ChainId): string {
     case ChainId.BNB:
       return 'https://bsc-dataseed1.binance.org'
     case ChainId.AVALANCHE:
-      return 'https://api.avax.network/ext/bc/C/rpc' 
+      return 'https://api.avax.network/ext/bc/C/rpc'
+    case ChainId.BASE:
+      return 'https://mainnet.base.org'
+    case ChainId.BASE_GOERLI:
+      return 'https://goerli.base.org'
     default:
   }
   throw new Error('Unsupported ChainId')