@uniswap/token-list-bridge-utils 1.0.8 → 1.1.1

package/src/providers/MappingProvider.ts

@@ -1,7 +1,7 @@
-import { PolygonMappedTokenData } from '../constants/types'
+import { GenericMappedTokenData, PolygonMappedTokenData } from '../constants/types'
 
 export interface MappingProvider {
   provide(): Promise<
-    PolygonMappedTokenData | { [key: string]: string | undefined }
+    PolygonMappedTokenData | GenericMappedTokenData
   >
 }

package/src/providers/OptimismMappingProvider.ts

@@ -1,6 +1,7 @@
 import { MappingProvider } from './MappingProvider'
 import { ChainId } from '../constants/chainId'
 import { getTokenList } from '../utils'
+import { GenericMappedTokenData } from '../constants/types'
 
 const optimismTokenListURL =
   'https://raw.githubusercontent.com/' +
@@ -12,7 +13,7 @@ const optimismTokenListURL =
  * This provider provides the l1->l2(Optimism) token mappings.
  */
 export class OptimismMappingProvider implements MappingProvider {
-  async provide(): Promise<{ [key: string]: string | undefined }> {
+  async provide(): Promise<GenericMappedTokenData> {
     const tokens: { [key: string]: string | undefined } = {}
 
     let optimismTokens = await getTokenList(optimismTokenListURL)

package/src/providers/PolygonMappingProvider.ts

@@ -2,8 +2,9 @@ import axios from 'axios'
 import { MappingProvider } from './MappingProvider'
 import { PolygonMappedTokenData } from '../constants/types'
 
-const url = 'https://tokenmapper.api.matic.today/api/v1/mapping?'
-const params = 'map_type=[%22POS%22]&chain_id=137&limit=200&offset='
+// called from https://mapper.polygon.technology
+const url = 'https://open-api.polygon.technology/api/v1/info/all-mappings'
+const access_token = '504afd90-3228-4df9-9d88-9b4d70646101'
 
 /**
  * The Polygon team manually maintains the mapping via user submissions at
@@ -13,22 +14,15 @@ const params = 'map_type=[%22POS%22]&chain_id=137&limit=200&offset='
  */
 export class PolygonMappingProvider implements MappingProvider {
   async provide(): Promise<PolygonMappedTokenData> {
-    let offset = 0
+    const response = await axios.get(url, {
+      headers: { 'x-access-token': access_token },
+    })
     const tokens: PolygonMappedTokenData = {}
-    while (true) {
-      const response = await axios.get(`${url}${params}${offset}`)
 
-      if (response.data.message === 'success') {
-        for (const token of response.data.data.mapping) {
-          tokens[token.root_token.toLowerCase()] = token
-        }
-
-        if (response.data.data.has_next_page === true) {
-          offset += 200
-          continue
-        }
+    for (const token of response.data) {
+      if (token.isPos) {
+        tokens[token.rootToken.toLowerCase()] = token
       }
-      break
     }
     return tokens
   }

package/src/providers/index.ts

@@ -13,80 +13,103 @@ import {
 import ERC20Abi from '../abis/erc20'
 // TODO: use ethers for contract calls (without performance reduction).
 import Web3 from 'web3'
+import {
+  GenericMappedTokenData,
+  PolygonMappedTokenData,
+} from '../constants/types'
 
 const web3 = new Web3()
 
+// chains we support fetching mappings for (can be different than the l2ChainIds arg for buildList)
+const SUPPORTED_L2_CHAINS = [
+  ChainId.ARBITRUM_ONE,
+  ChainId.POLYGON,
+  ChainId.OPTIMISM,
+]
+
 export async function buildList(
-  chainId: ChainId,
+  l2ChainIds: Array<ChainId>,
   l1TokenList: TokenList
 ): Promise<TokenList> {
-  web3.setProvider(getRpcUrl(chainId))
-  const tokenAddressMap = await getMappingProvider(
-    chainId,
+  const multiChainedTokens: TokenInfo[] = []
+  const chainIdToMappingsMap = await generateTokenMappings(
+    l2ChainIds,
     l1TokenList
-  ).provide()
-  const mappedTokens = []
-  for (const rootToken of l1TokenList.tokens) {
-    const childToken = tokenAddressMap[rootToken.address.toLowerCase()]
-    const childTokenAddress = childToken
-      ? ethers.utils.getAddress(
-          typeof childToken === 'object' ? childToken.child_token : childToken
-        )
-      : undefined
-    const childTokenValid = Boolean(
-      childTokenAddress &&
-        (typeof childToken === 'object' ? !childToken.deleted : true) &&
-        (await hasExistingTokenContract(childTokenAddress, chainId))
-    )
-
-    if (rootToken.chainId === ChainId.MAINNET) {
-      // build extension info if available
-      const toRootExtensions = childTokenValid
-        ? {
-            extensions: {
-              bridgeInfo: {
-                [rootToken.chainId]: {
-                  tokenAddress: ethers.utils.getAddress(rootToken.address),
-                },
-              },
-            },
-          }
-        : {}
-
-      const toChildExtensions = childTokenValid
-        ? {
-            extensions: {
-              bridgeInfo: {
-                [chainId]: {
-                  tokenAddress: childTokenAddress,
-                },
-              },
-            },
+  )
+  for (const l1Token of l1TokenList.tokens) {
+    if (l1Token.chainId === ChainId.MAINNET) {
+      const chainIdToChildTokenDetailsMap: {
+        [key: number]: {
+          childTokenValid: boolean
+          childTokenAddress: string | undefined
+        }
+      } = {}
+      const l2MappingExtension = {
+        extensions: {
+          bridgeInfo: {},
+        },
+      }
+      // build out the extensions.bridgeInfo data containing mappings for each L2 chain
+      await Promise.all(
+        l2ChainIds.map(async (chainId) => {
+          chainIdToChildTokenDetailsMap[chainId] = await getChildTokenDetails(
+            l1Token,
+            chainId,
+            chainIdToMappingsMap
+          )
+          if (chainIdToChildTokenDetailsMap[chainId].childTokenValid) {
+            l2MappingExtension.extensions.bridgeInfo[chainId] = {
+              tokenAddress:
+                chainIdToChildTokenDetailsMap[chainId].childTokenAddress,
+            }
           }
-        : {}
+        })
+      )
 
-      const rootTokenInfo: TokenInfo = {
-        ...rootToken,
-        ...toChildExtensions,
-      } as unknown as TokenInfo
+      // build the TokenInfo objects with bridgeInfo extension
+      l2ChainIds.concat([ChainId.MAINNET]).forEach((chainId) => {
+        if (
+          chainId === ChainId.MAINNET ||
+          chainIdToChildTokenDetailsMap[chainId].childTokenValid
+        ) {
+          const tokenInfo: TokenInfo =
+            chainId === ChainId.MAINNET
+              ? ({
+                  ...l1Token,
+                  extensions:
+                    Object.keys(l2MappingExtension.extensions.bridgeInfo)
+                      .length > 0
+                      ? {
+                          bridgeInfo: l2MappingExtension.extensions.bridgeInfo,
+                        }
+                      : undefined,
+                } as unknown as TokenInfo)
+              : ({
+                  ...l1Token,
+                  chainId: chainId,
+                  address:
+                    chainIdToChildTokenDetailsMap[chainId].childTokenAddress,
+                  extensions: {
+                    bridgeInfo: {
+                      [ChainId.MAINNET]: {
+                        tokenAddress: ethers.utils.getAddress(l1Token.address),
+                      },
+                    },
+                  },
+                } as unknown as TokenInfo)
 
-      if (childTokenValid) {
-        const childTokenInfo: TokenInfo = {
-          ...rootToken,
-          chainId: chainId,
-          address: childTokenAddress,
-          ...toRootExtensions,
-        } as unknown as TokenInfo
-        mappedTokens.push(childTokenInfo)
-      }
-      mappedTokens.push(rootTokenInfo)
+          multiChainedTokens.push(tokenInfo)
+        }
+      })
     }
   }
+
+  // build and return final chainified token list
   const tokenList = {
-    name: `(ChainId: ${chainId}) ${l1TokenList.name}`,
+    name: `(ChainIds: ${l2ChainIds}) ${l1TokenList.name}`,
     timestamp: new Date().toISOString(),
     version: l1TokenList.version,
-    tokens: mappedTokens.sort(compareTokenInfos),
+    tokens: multiChainedTokens.sort(compareTokenInfos),
   }
 
   return tokenList
@@ -94,12 +117,14 @@ export async function buildList(
 
 // using a symbol lookup contract call to check whether the token exists on the L2
 async function hasExistingTokenContract(address: string, chainId: ChainId) {
+  web3.setProvider(getRpcUrl(chainId))
   try {
     const contract: Contract = new web3.eth.Contract(ERC20Abi, address)
     await getTokenSymbolFromContract(contract)
   } catch {
     return false
   }
+
   return true
 }
 
@@ -112,6 +137,65 @@ function getMappingProvider(chainId: ChainId, l1TokenList: TokenList) {
     case ChainId.POLYGON:
       return new PolygonMappingProvider()
     default:
-      throw new Error(`Chain ${chainId} not supported.`)
+      throw new Error(`Chain ${chainId} not supported for fetching mappings.`)
+  }
+}
+
+async function generateTokenMappings(
+  chainIds: ChainId[],
+  l1TokenList: TokenList
+) {
+  const chainIdToMappingsMap: {
+    [key: number]: PolygonMappedTokenData | GenericMappedTokenData
+  } = {}
+
+  for (const chainId of chainIds) {
+    if (SUPPORTED_L2_CHAINS.includes(chainId)) {
+      chainIdToMappingsMap[chainId] = await getMappingProvider(
+        chainId,
+        l1TokenList
+      ).provide()
+    }
+  }
+
+  return chainIdToMappingsMap
+}
+
+// handles both string and object cases for childToken (Polygon mappings return object)
+async function getChildTokenDetails(
+  l1Token: TokenInfo,
+  chainId: ChainId,
+  chainIdToMappingsMap: {
+    [key: number]: PolygonMappedTokenData | GenericMappedTokenData
+  }
+): Promise<{
+  childTokenValid: boolean
+  childTokenAddress: string | undefined
+}> {
+  const existingMapping: undefined | string =
+    l1Token?.extensions?.bridgeInfo?.[chainId]?.tokenAddress
+  // use the externally fetched mappings if manual entry doesn't exist for the token/chain mapping
+  // and the given L2 chain is supported for fetching mappings
+  if (SUPPORTED_L2_CHAINS.includes(chainId) && existingMapping === undefined) {
+    const childToken =
+      chainIdToMappingsMap[chainId][l1Token.address.toLowerCase()]
+
+    const childTokenAddress = childToken
+      ? ethers.utils.getAddress(
+          typeof childToken === 'object' ? childToken.childToken : childToken
+        )
+      : undefined
+    const childTokenValid = Boolean(
+      childTokenAddress &&
+        (await hasExistingTokenContract(childTokenAddress, chainId))
+    )
+    return {
+      childTokenValid: childTokenValid,
+      childTokenAddress: childTokenAddress,
+    }
+  }
+  return {
+    childTokenValid: !!existingMapping,
+    childTokenAddress: existingMapping,
   }
 }

package/src/utils.ts

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