@uniswap/token-list-bridge-utils 0.1.1-beta.1 → 0.1.1-beta.2

package/src/constants/types.ts

@@ -0,0 +1,28 @@
+export interface PolygonMappedToken {
+  chainId: number
+  child_address_passed_by_user: boolean
+  child_token: string
+  count: number
+  created_at: string
+  decimals: number
+  deleted: boolean
+  id: number
+  map_type: 'POS'
+  mintable: boolean
+  name: string
+  new_child_token: string
+  new_mintable: boolean
+  owner: string
+  reason: string
+  reason_for_remapping: string
+  remapping_allowed: boolean
+  remapping_request_submitted: boolean
+  remapping_verified: boolean
+  root_token: string
+  status: number
+  symbol: string
+  token_type: string // ERC20
+  updated_at: string
+  uri: string
+}
+export type PolygonMappedTokenData = { [key: string]: PolygonMappedToken }

package/src/fixtures/index.ts

@@ -1,7 +1,12 @@
 import { Token } from '@uniswap/sdk-core'
 import { TokenInfo, TokenList } from '@uniswap/token-lists'
 import { ChainId } from '../constants/chainId'
-import { DAI, DAI_ARBITRUM_ONE, DAI_POLYGON } from '../constants/tokens'
+import {
+  DAI,
+  DAI_ARBITRUM_ONE,
+  DAI_OPTIMISM,
+  DAI_POLYGON,
+} from '../constants/tokens'
 import { compareTokenInfos } from '../utils'
 
 export const Tokens: Partial<Record<ChainId, Record<string, TokenInfo>>> = {
@@ -14,6 +19,9 @@ export const Tokens: Partial<Record<ChainId, Record<string, TokenInfo>>> = {
   [ChainId.POLYGON]: {
     DAI: tokenToTokenInfo(DAI_POLYGON),
   },
+  [ChainId.OPTIMISM]: {
+    DAI: tokenToTokenInfo(DAI_OPTIMISM),
+  },
 }
 
 export const sampleL1TokenList: TokenList = {
@@ -40,8 +48,8 @@ export const arbedSampleTokenList = {
         bridgeInfo: {
           [ChainId.MAINNET]: {
             tokenAddress: DAI.address,
-            originBridgeAddress: arbBridgeL2Address,
-            destBridgeAddress: arbBridgeL1Address,
+            // originBridgeAddress: arbBridgeL2Address,
+            // destBridgeAddress: arbBridgeL1Address,
           },
         },
       },
@@ -52,8 +60,8 @@ export const arbedSampleTokenList = {
         bridgeInfo: {
           [ChainId.ARBITRUM_ONE]: {
             tokenAddress: DAI_ARBITRUM_ONE.address,
-            destBridgeAddress: arbBridgeL2Address,
-            originBridgeAddress: arbBridgeL1Address,
+            // destBridgeAddress: arbBridgeL2Address,
+            // originBridgeAddress: arbBridgeL1Address,
           },
         },
       },
@@ -87,6 +95,33 @@ export const polygonedSampleTokenList = {
   ].sort(compareTokenInfos),
 }
 
+export const optimizedSampleTokenList = {
+  ...sampleL1TokenList,
+  name: 'Optimized Sample',
+  tokens: [
+    {
+      ...Tokens[ChainId.OPTIMISM]!.DAI,
+      extensions: {
+        bridgeInfo: {
+          [ChainId.MAINNET]: {
+            tokenAddress: DAI.address,
+          },
+        },
+      },
+    } as unknown as TokenInfo,
+    {
+      ...(Tokens[ChainId.MAINNET]!.DAI as unknown as TokenInfo),
+      extensions: {
+        bridgeInfo: {
+          [ChainId.OPTIMISM]: {
+            tokenAddress: DAI_OPTIMISM.address,
+          },
+        },
+      },
+    } as unknown as TokenInfo,
+  ].sort(compareTokenInfos),
+}
+
 function tokenToTokenInfo({
   chainId,
   address,

package/src/index.test.ts

@@ -1,27 +1,46 @@
 import { TokenInfo } from '@uniswap/token-lists'
 import { chainify, chainifyTokenList, mergeTokenLists } from '.'
 import { ChainId } from './constants/chainId'
-import { DAI, DAI_ARBITRUM_ONE, DAI_POLYGON } from './constants/tokens'
+import { ArbitrumMappingProvider } from './providers/ArbitrumMappingProvider'
+import {
+  DAI,
+  DAI_ARBITRUM_ONE,
+  DAI_OPTIMISM,
+  DAI_POLYGON,
+} from './constants/tokens'
 import {
-  arbBridgeL1Address,
-  arbBridgeL2Address,
   arbedSampleTokenList,
+  optimizedSampleTokenList,
   polygonedSampleTokenList,
   sampleL1TokenList,
   Tokens,
 } from './fixtures'
 
+jest.setTimeout(15000)
+
 describe(chainifyTokenList, () => {
-  it('no-ops on Optimism', async () => {
+  it('outputs Optimism list correctly', async () => {
     const tokenList = await chainifyTokenList(
-      ChainId.ARBITRUM_ONE,
+      ChainId.OPTIMISM,
       sampleL1TokenList
     )
 
-    expect(tokenList).toEqual(tokenList)
+    expect(tokenList).toBeDefined()
+    expect(tokenList?.version).toEqual(polygonedSampleTokenList.version)
+    expect(
+      tokenList?.tokens.map((t) => [t.address, t.chainId, t.extensions])
+    ).toEqual(
+      // ignores other metadata
+      optimizedSampleTokenList.tokens.map((t) => [
+        t.address,
+        t.chainId,
+        t.extensions,
+      ])
+    )
   })
 
   it('outputs arbitrum list correctly', async () => {
+    mockArbitrumProvider()
     const tokenList = await chainifyTokenList(
       ChainId.ARBITRUM_ONE,
       sampleL1TokenList
@@ -129,8 +148,8 @@ describe(mergeTokenLists, () => {
             },
             [ChainId.ARBITRUM_ONE]: {
               tokenAddress: DAI_ARBITRUM_ONE.address,
-              destBridgeAddress: arbBridgeL2Address,
-              originBridgeAddress: arbBridgeL1Address,
+              // destBridgeAddress: arbBridgeL2Address,
+              // originBridgeAddress: arbBridgeL1Address,
             },
           },
         },
@@ -151,8 +170,8 @@ describe(mergeTokenLists, () => {
           bridgeInfo: {
             [ChainId.MAINNET]: {
               tokenAddress: DAI.address,
-              originBridgeAddress: arbBridgeL2Address,
-              destBridgeAddress: arbBridgeL1Address,
+              // originBridgeAddress: arbBridgeL2Address,
+              // destBridgeAddress: arbBridgeL1Address,
             },
           },
         },
@@ -160,9 +179,9 @@ describe(mergeTokenLists, () => {
     ])
   })
 })
-
 describe(chainify, () => {
   it('provides bridge extensions', async () => {
+    mockArbitrumProvider()
     const chainified = await chainify(sampleL1TokenList)
 
     expect(chainified.tokens).toEqual([
@@ -170,13 +189,27 @@ describe(chainify, () => {
         ...Tokens[ChainId.MAINNET]!.DAI,
         extensions: {
           bridgeInfo: {
+            [ChainId.OPTIMISM]: {
+              tokenAddress: DAI_OPTIMISM.address,
+            },
             [ChainId.POLYGON]: {
               tokenAddress: DAI_POLYGON.address,
             },
             [ChainId.ARBITRUM_ONE]: {
               tokenAddress: DAI_ARBITRUM_ONE.address,
-              destBridgeAddress: arbBridgeL2Address,
-              originBridgeAddress: arbBridgeL1Address,
+              // destBridgeAddress: arbBridgeL2Address,
+              // originBridgeAddress: arbBridgeL1Address,
+            },
+          },
+        },
+      },
+      {
+        ...Tokens[ChainId.OPTIMISM]!.DAI,
+        name: 'Dai Stablecoin',
+        extensions: {
+          bridgeInfo: {
+            [ChainId.MAINNET]: {
+              tokenAddress: DAI.address,
             },
           },
         },
@@ -196,16 +229,25 @@ describe(chainify, () => {
         extensions: {
           bridgeInfo: {
             [ChainId.MAINNET]: {
-              tokenAddress: DAI.address.toLowerCase(),
-              originBridgeAddress: arbBridgeL2Address,
-              destBridgeAddress: arbBridgeL1Address,
+              tokenAddress: DAI.address,
+              // originBridgeAddress: arbBridgeL2Address,
+              // destBridgeAddress: arbBridgeL1Address,
             },
           },
         },
-        logoURI:
-          'https://assets.coingecko.com/coins/images/9956/thumb/4943.png?1636636734',
         name: 'Dai Stablecoin',
       },
     ])
   })
 })
+
+// Mocking arb provider due to required infura key for network call
+function mockArbitrumProvider() {
+  let arbTokenMap: { [key: string]: string | undefined } = {}
+  const DAI_ADDRESS: string = DAI.address.toLowerCase()
+  arbTokenMap[DAI_ADDRESS.toLowerCase()] =
+    DAI_ARBITRUM_ONE.address.toLowerCase()
+  var mockArbProvide = jest.fn()
+  mockArbProvide.mockImplementation(() => Promise.resolve(arbTokenMap))
+  ArbitrumMappingProvider.prototype.provide = mockArbProvide
+}

package/src/index.ts

@@ -1,11 +1,11 @@
 import { TokenList } from '@uniswap/token-lists'
 import { cloneDeep, groupBy, merge } from 'lodash'
 import { ChainId } from './constants/chainId'
-import { getMappingProvider } from './providers'
+import { buildList } from './providers'
 import {
   compareTokenInfos,
   getTokenList,
-  TokenListOrFetchableTokenList
+  TokenListOrFetchableTokenList,
 } from './utils'
 import { verifyExtensions } from './verify'
 
@@ -49,9 +49,8 @@ export async function chainifyTokenList(
   l1TokenListOrPathOrUrl: TokenListOrFetchableTokenList
 ): Promise<TokenList> {
   try {
-    const tokenList = await getMappingProvider(chainId).provide(
-      await getTokenList(l1TokenListOrPathOrUrl)
-    )
+    const l1TokenList = await getTokenList(l1TokenListOrPathOrUrl)
+    const tokenList = await buildList(chainId, l1TokenList)
     return verifyExtensions(tokenList)
   } catch (e) {
     throw new Error(`An error occured: ${e}`)
@@ -79,7 +78,6 @@ export function mergeTokenLists(
     const merged = merge(group[0], group[1])
     if (merged.extensions?.bridgeInfo) {
       // remove reference to self-chain from merge
-      // @ts-expect-error TokenList schema doesn't yet define objects
       delete merged.extensions.bridgeInfo[merged.chainId]
     }
     return merged
@@ -89,4 +87,4 @@ export function mergeTokenLists(
     ...primary,
     tokens: merged.sort(compareTokenInfos),
   })
-}
+}

package/src/providers/ArbitrumMappingProvider.ts

@@ -1,28 +1,38 @@
-import { TokenList } from '@uniswap/token-lists'
-import { generateTokenList } from '../arb-token-lists/src/lib/token_list_gen'
-import { compareTokenInfos } from '../utils'
 import { MappingProvider } from './MappingProvider'
+import { getNetworkConfig } from '../arbitrum/instantiate_bridge'
+import { getL2TokenAddressesFromL1 } from '../arbitrum/gateway'
+import { TokenList } from '@uniswap/token-lists'
 
 /**
- * The Arbitrum team maintains an (unpublished) package to `arbify` an L1
- * token list.
- *
- * The provider simply invokes this package which we host as a submodule.
+ * This provider provides the l1->l2(Arbitrum) address mappings using the arbitrum SDK.
  */
-
 export class ArbitrumMappingProvider implements MappingProvider {
-  async provide(l1TokenList: TokenList): Promise<TokenList> {
-    const arbedTokenList = (await generateTokenList(
-      l1TokenList,
-      /*prevArbTokenList=*/ undefined,
-      {
-        includeAllL1Tokens: true,
-      }
-    )) as unknown as TokenList
-
-    return {
-      ...arbedTokenList,
-      tokens: arbedTokenList.tokens.sort(compareTokenInfos),
-    }
+  l1TokenList: TokenList
+
+  constructor(l1TokenList: TokenList) {
+    this.l1TokenList = l1TokenList
+  }
+
+  async provide(): Promise<{ [key: string]: string | undefined }> {
+    let tokens: { [key: string]: string | undefined } = {}
+
+    const { l1, l2 } = await getNetworkConfig()
+
+    let tokenAddresses = this.l1TokenList.tokens.map((token) =>
+      token.address.toLowerCase()
+    )
+
+    const l2AddressesFromL1 = await getL2TokenAddressesFromL1(
+      tokenAddresses,
+      l1.multiCaller,
+      l2.network.tokenBridge.l1GatewayRouter
+    )
+
+    tokens = tokenAddresses.reduce(
+      (obj, key, index) => ({ ...obj, [key]: l2AddressesFromL1[index] }),
+      {}
+    )
+
+    return tokens
   }
 }

package/src/providers/MappingProvider.ts

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

package/src/providers/OptimismMappingProvider.ts

@@ -1,13 +1,29 @@
-import { TokenList } from '@uniswap/token-lists'
 import { MappingProvider } from './MappingProvider'
+import { ChainId } from '../constants/chainId'
+import { getTokenList } from '../utils'
+
+const optimismTokenListURL =
+  'https://raw.githubusercontent.com/' +
+  'ethereum-optimism/ethereum-optimism.github.io/2138386277e4156d159615d1840882cecc398437/optimism.tokenlist.json'
 
 /**
- * The Optimism L2 mapping is manually maintained by the Optimism team.
+ * The Optimism L2 mapping (linked above) is manually maintained by the Optimism team.
  *
- * This provider mostly no-ops, i.e. grabs the list and returns it.
+ * This provider provides the l1->l2(Optimism) token mappings.
  */
 export class OptimismMappingProvider implements MappingProvider {
-  async provide(l1TokenList: TokenList): Promise<TokenList> {
-    return l1TokenList
+  async provide(): Promise<{ [key: string]: string | undefined }> {
+    const tokens: { [key: string]: string | undefined } = {}
+
+    let optimismTokens = await getTokenList(optimismTokenListURL)
+
+    for (const token of optimismTokens.tokens) {
+      if (token.chainId === ChainId.MAINNET) {
+        tokens[token.address.toLowerCase()] =
+          token?.extensions?.bridgeInfo![ChainId.OPTIMISM].tokenAddress
+      }
+    }
+
+    return tokens
   }
 }

package/src/providers/PolygonMappingProvider.ts

@@ -1,127 +1,35 @@
-import { TokenInfo, TokenList } from '@uniswap/token-lists'
 import axios from 'axios'
-import { compareTokenInfos } from '../utils'
 import { MappingProvider } from './MappingProvider'
+import { PolygonMappedTokenData } from '../constants/types'
 
-interface PolygonMappedToken {
-  chainId: number
-  child_address_passed_by_user: boolean
-  child_token: string
-  count: number
-  created_at: string
-  decimals: number
-  deleted: boolean
-  id: number
-  map_type: 'POS'
-  mintable: boolean
-  name: string
-  new_child_token: string
-  new_mintable: boolean
-  owner: string
-  reason: string
-  reason_for_remapping: string
-  remapping_allowed: boolean
-  remapping_request_submitted: boolean
-  remapping_verified: boolean
-  root_token: string
-  status: number
-  symbol: string
-  token_type: string // ERC20
-  updated_at: string
-  uri: string
-}
-
-type PolygonMappedTokenData = { [key: string]: PolygonMappedToken }
+const url = 'https://tokenmapper.api.matic.today/api/v1/mapping?'
+const params = 'map_type=[%22POS%22]&chain_id=137&limit=200&offset='
 
 /**
  * The Polygon team manually maintains the mapping via user submissions at
  * https://mapper.polygon.technology.
+ *
+ * This provider provides the l1->l2(Polygon) token mappings.
  */
 export class PolygonMappingProvider implements MappingProvider {
-  async provide(l1TokenList: TokenList): Promise<TokenList> {
-    const polygonTokens = await fetchPolygonMappedTokens()
-
-    const mappedTokens = []
-    for (const rootToken of l1TokenList.tokens) {
-      const childToken = polygonTokens[rootToken.address.toLowerCase()]
-      const childTokenValid = Boolean(childToken && !childToken.deleted)
-
-      // build extension info if available
-      const toRootExtensions = childTokenValid
-        ? {
-            extensions: {
-              bridgeInfo: {
-                [rootToken.chainId]: {
-                  tokenAddress: childToken.root_token,
-                },
-              },
-            },
-          }
-        : {}
-      const toChildExtensions = childTokenValid
-        ? {
-            extensions: {
-              bridgeInfo: {
-                [childToken.chainId]: {
-                  tokenAddress: childToken.child_token,
-                },
-              },
-            },
-          }
-        : {}
-
-      const rootTokenInfo: TokenInfo = {
-        ...rootToken,
-        ...toChildExtensions,
-      } as unknown as TokenInfo
-
-      const childTokenInfo: TokenInfo = {
-        ...rootToken,
-        chainId: childToken.chainId,
-        name: childToken.name ?? rootToken.name,
-        symbol: childToken.symbol ?? rootToken.symbol,
-        address: childToken.child_token,
-        ...toRootExtensions,
-      } as unknown as TokenInfo
-
-      mappedTokens.push(rootTokenInfo)
-      mappedTokens.push(childTokenInfo)
-    }
-
-    const tokenList = {
-      name: `Polygon ${l1TokenList.name}`,
-      timestamp: new Date().toISOString(),
-      version: l1TokenList.version,
-      tokens: mappedTokens.sort(compareTokenInfos),
-    }
-
-    return tokenList
-  }
-}
-
-const url = 'https://tokenmapper.api.matic.today/api/v1/mapping?'
-const params = 'map_type=[%22POS%22]&chain_id=137&limit=200&offset='
-
-async function fetchPolygonMappedTokens(): Promise<PolygonMappedTokenData> {
-  let offset = 0
-  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
+  async provide(): Promise<PolygonMappedTokenData> {
+    let offset = 0
+    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
+        }
       }
+      break
     }
-
-    break
+    return tokens
   }
-
-  return tokens
 }

package/src/providers/index.ts

@@ -2,11 +2,90 @@ import { ChainId } from '../constants/chainId'
 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'
 
-export function getMappingProvider(chainId: ChainId) {
+export async function buildList(
+  chainId: ChainId,
+  l1TokenList: TokenList
+): Promise<TokenList> {
+  const tokenAddressMap = await getMappingProvider(
+    chainId,
+    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!
+                  ),
+                },
+              },
+            },
+          }
+        : {}
+
+      const rootTokenInfo: TokenInfo = {
+        ...rootToken,
+        ...toChildExtensions,
+      } as unknown as TokenInfo
+
+      const childTokenInfo: TokenInfo = {
+        ...rootToken,
+        chainId: chainId,
+        address: ethers.utils.getAddress(
+          typeof childToken === 'object' ? childToken.child_token : childToken!
+        ),
+        ...toRootExtensions,
+      } as unknown as TokenInfo
+
+      mappedTokens.push(rootTokenInfo)
+      if (childTokenValid) {
+        mappedTokens.push(childTokenInfo)
+      }
+    }
+  }
+  const tokenList = {
+    name: `(ChainId: ${chainId}) ${l1TokenList.name}`,
+    timestamp: new Date().toISOString(),
+    version: l1TokenList.version,
+    tokens: mappedTokens.sort(compareTokenInfos),
+  }
+
+  return tokenList
+}
+
+function getMappingProvider(chainId: ChainId, l1TokenList: TokenList) {
   switch (chainId) {
     case ChainId.ARBITRUM_ONE:
-      return new ArbitrumMappingProvider()
+      return new ArbitrumMappingProvider(l1TokenList)
     case ChainId.OPTIMISM:
       return new OptimismMappingProvider()
     case ChainId.POLYGON: