@uniswap/token-list-bridge-utils 1.0.7 → 1.1.0

package/src/abis/erc20.ts

@@ -0,0 +1,226 @@
+import { AbiItem } from 'web3-utils'
+
+const abi: AbiItem[] = [
+  {
+    constant: true,
+    inputs: [],
+    name: 'name',
+    outputs: [
+      {
+        name: '',
+        type: 'string',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: '_spender',
+        type: 'address',
+      },
+      {
+        name: '_value',
+        type: 'uint256',
+      },
+    ],
+    name: 'approve',
+    outputs: [
+      {
+        name: '',
+        type: 'bool',
+      },
+    ],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'totalSupply',
+    outputs: [
+      {
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: '_from',
+        type: 'address',
+      },
+      {
+        name: '_to',
+        type: 'address',
+      },
+      {
+        name: '_value',
+        type: 'uint256',
+      },
+    ],
+    name: 'transferFrom',
+    outputs: [
+      {
+        name: '',
+        type: 'bool',
+      },
+    ],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'decimals',
+    outputs: [
+      {
+        name: '',
+        type: 'uint8',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: '_owner',
+        type: 'address',
+      },
+    ],
+    name: 'balanceOf',
+    outputs: [
+      {
+        name: 'balance',
+        type: 'uint256',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'symbol',
+    outputs: [
+      {
+        name: '',
+        type: 'string',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: '_to',
+        type: 'address',
+      },
+      {
+        name: '_value',
+        type: 'uint256',
+      },
+    ],
+    name: 'transfer',
+    outputs: [
+      {
+        name: '',
+        type: 'bool',
+      },
+    ],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: '_owner',
+        type: 'address',
+      },
+      {
+        name: '_spender',
+        type: 'address',
+      },
+    ],
+    name: 'allowance',
+    outputs: [
+      {
+        name: '',
+        type: 'uint256',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    payable: true,
+    stateMutability: 'payable',
+    type: 'fallback',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: 'owner',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        name: 'spender',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'Approval',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: 'from',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        name: 'to',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        name: 'value',
+        type: 'uint256',
+      },
+    ],
+    name: 'Transfer',
+    type: 'event',
+  },
+]
+
+export default abi

package/src/arbitrum/set_rpc.ts

@@ -1,6 +1,7 @@
 import { config } from 'dotenv'
+import { ChainId } from '../constants/chainId'
+import { getRpcUrl } from '../utils'
 
-// fall back to https://cloudflare-eth.com/ if MAINNET_RPC not provided in an .env file
+// MAINNET_RPC value is required for arb-sdk. fall back to https://cloudflare-eth.com/ if MAINNET_RPC not provided in an .env file
 config()
-process.env.MAINNET_RPC =
-  process.env.MAINNET_RPC || 'https://cloudflare-eth.com/'
+process.env.MAINNET_RPC ??= getRpcUrl(ChainId.MAINNET)

package/src/constants/chainId.ts

@@ -10,4 +10,6 @@ export enum ChainId {
 
   POLYGON = 137,
   POLYGON_MUMBAI = 80001,
+
+  CELO = 42220,
 }

package/src/constants/types.ts

@@ -25,4 +25,8 @@ export interface PolygonMappedToken {
   updated_at: string
   uri: string
 }
-export type PolygonMappedTokenData = { [key: string]: PolygonMappedToken }
+
+export type GenericMappedTokenData = { [key: string]: string | undefined }
+
+// Polygon has its own type here since their api gives us more info than just the mapped token address
+export type PolygonMappedTokenData = { [key: string]: PolygonMappedToken }

package/src/index.test.ts

@@ -20,7 +20,7 @@ jest.setTimeout(15000)
 describe(chainifyTokenList, () => {
   it('outputs Optimism list correctly', async () => {
     const tokenList = await chainifyTokenList(
-      ChainId.OPTIMISM,
+      [ChainId.OPTIMISM],
       sampleL1TokenList
     )
 
@@ -40,7 +40,7 @@ describe(chainifyTokenList, () => {
 
   it('outputs arbitrum list correctly', async () => {
     const tokenList = await chainifyTokenList(
-      ChainId.ARBITRUM_ONE,
+      [ChainId.ARBITRUM_ONE],
       sampleL1TokenList
     )
 
@@ -64,7 +64,7 @@ describe(chainifyTokenList, () => {
 
   it('outputs polygon list correctly', async () => {
     const tokenList = await chainifyTokenList(
-      ChainId.POLYGON,
+      [ChainId.POLYGON],
       sampleL1TokenList
     )
 

package/src/index.ts

@@ -18,39 +18,33 @@ export async function chainify(
   l1TokenListOrPathOrUrl: TokenListOrFetchableTokenList
 ): Promise<TokenList> {
   const l1TokenList = await getTokenList(l1TokenListOrPathOrUrl)
-
-  const optimisimed = await chainifyTokenList(
-    ChainId.OPTIMISM,
-    l1TokenListOrPathOrUrl
-  )
-  const polygoned = await chainifyTokenList(
+  const l2Chains = [
     ChainId.POLYGON,
-    l1TokenListOrPathOrUrl
-  )
-  const arbified = await chainifyTokenList(
     ChainId.ARBITRUM_ONE,
-    l1TokenListOrPathOrUrl
-  )
+    ChainId.OPTIMISM,
+    ChainId.CELO,
+  ]
 
+  const chainified = await chainifyTokenList(l2Chains, l1TokenListOrPathOrUrl)
   return mergeTokenLists(
     l1TokenList, // providing l1 first to make sure duplicated tokens resolve to this list
-    mergeTokenLists(mergeTokenLists(arbified, optimisimed), polygoned)
+    chainified
   )
 }
 
 /**
  * Given a network and a TokenList, returns the TokenList with `extensions` filled.
- * @param chainId chainId to operate on
+ * @param l2ChainIds layer 2 chainIds to operate on
  * @param l1TokenListOrPathOrUrl either an L1 TokenList object or a path/url to a TokenList
  * @returns L1 TokenList with `extensions` filled for the given network
  */
 export async function chainifyTokenList(
-  chainId: ChainId,
+  l2ChainIds: Array<ChainId>,
   l1TokenListOrPathOrUrl: TokenListOrFetchableTokenList
 ): Promise<TokenList> {
   try {
     const l1TokenList = await getTokenList(l1TokenListOrPathOrUrl)
-    const tokenList = await buildList(chainId, l1TokenList)
+    const tokenList = await buildList(l2ChainIds, l1TokenList)
     return verifyExtensions(tokenList)
   } catch (e) {
     throw new Error(`An error occured: ${e}`)

package/src/providers/ArbitrumMappingProvider.ts

@@ -2,6 +2,7 @@ import { MappingProvider } from './MappingProvider'
 import { getNetworkConfig } from '../arbitrum/instantiate_bridge'
 import { getL2TokenAddressesFromL1 } from '../arbitrum/gateway'
 import { TokenList } from '@uniswap/token-lists'
+import { GenericMappedTokenData } from '../constants/types'
 
 /**
  * This provider provides the l1->l2(Arbitrum) address mappings using the arbitrum SDK.
@@ -13,7 +14,7 @@ export class ArbitrumMappingProvider implements MappingProvider {
     this.l1TokenList = l1TokenList
   }
 
-  async provide(): Promise<{ [key: string]: string | undefined }> {
+  async provide(): Promise<GenericMappedTokenData> {
     let tokens: { [key: string]: string | undefined } = {}
 
     const { l1, l2 } = await getNetworkConfig()

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/index.ts

@@ -1,88 +1,133 @@
 import { ChainId } from '../constants/chainId'
+import { Contract } from 'web3-eth-contract'
 import { ArbitrumMappingProvider } from './ArbitrumMappingProvider'
 import { OptimismMappingProvider } from './OptimismMappingProvider'
 import { PolygonMappingProvider } from './PolygonMappingProvider'
 import { TokenInfo, TokenList } from '@uniswap/token-lists'
-import { compareTokenInfos } from '../utils'
 import { ethers } from 'ethers'
+import {
+  compareTokenInfos,
+  getRpcUrl,
+  getTokenSymbolFromContract,
+} from '../utils'
+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> {
-  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 childTokenValid = Boolean(
-      childToken &&
-        (typeof childToken === 'object' ? !childToken.deleted : true)
-    )
-
-    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: ethers.utils.getAddress(
-                    typeof childToken === 'object'
-                      ? childToken.child_token
-                      : childToken!
-                  ),
-                },
-              },
-            },
+  )
+  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: ethers.utils.getAddress(
-            typeof childToken === 'object'
-              ? childToken.child_token
-              : childToken!
-          ),
-          ...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
 }
 
+// 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
+}
+
 function getMappingProvider(chainId: ChainId, l1TokenList: TokenList) {
   switch (chainId) {
     case ChainId.ARBITRUM_ONE:
@@ -92,6 +137,66 @@ 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.child_token : childToken
+        )
+      : undefined
+    const childTokenValid = Boolean(
+      childTokenAddress &&
+        (typeof childToken === 'object' ? !childToken.deleted : true) &&
+        (await hasExistingTokenContract(childTokenAddress, chainId))
+    )
+    return {
+      childTokenValid: childTokenValid,
+      childTokenAddress: childTokenAddress,
+    }
+  }
+  return {
+    childTokenValid: !!existingMapping,
+    childTokenAddress: existingMapping,
   }
 }

package/src/utils.ts

@@ -1,6 +1,8 @@
 import { TokenInfo, TokenList } from '@uniswap/token-lists'
 import { readFileSync, existsSync } from 'fs'
 import axios from 'axios'
+import { ChainId } from './constants/chainId'
+import { Contract } from 'web3-eth-contract'
 
 export type TokenListOrFetchableTokenList = TokenList | string
 
@@ -89,3 +91,29 @@ export const isTokenList = (obj: any) => {
     throw new Error('tokenlist typeguard error: token missing required key')
   }
 }
+
+export function getRpcUrl(chainId: ChainId): string {
+  switch (chainId) {
+    case ChainId.MAINNET:
+      return 'https://cloudflare-eth.com/'
+    case ChainId.OPTIMISM:
+      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:
+      return 'https://arb1.arbitrum.io/rpc'
+    case ChainId.ARBITRUM_RINKEBY:
+      return 'https://rinkeby.arbitrum.io/rpc'
+    case ChainId.POLYGON:
+      return 'https://polygon-rpc.com/'
+    case ChainId.POLYGON_MUMBAI:
+      return 'https://rpc-endpoints.superfluid.dev/mumbai'
+    default:
+  }
+  throw new Error('Unsupported ChainId')
+}
+
+export async function getTokenSymbolFromContract(tokenContract: Contract) {
+  const symbol = await Promise.all([tokenContract.methods.symbol().call()])
+  return symbol
+}