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

package/dist/constants/chainId.d.ts

@@ -6,5 +6,6 @@ export declare enum ChainId {
     OPTIMISM = 10,
     OPTIMISTIC_KOVAN = 69,
     POLYGON = 137,
-    POLYGON_MUMBAI = 80001
+    POLYGON_MUMBAI = 80001,
+    CELO = 42220
 }

package/dist/constants/types.d.ts

@@ -1,30 +1,11 @@
 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;
-    updated_at: string;
-    uri: string;
+    rootToken: string;
+    childToken: string;
+    isPos?: boolean;
 }
+export declare type GenericMappedTokenData = {
+    [key: string]: string | undefined;
+};
 export declare type PolygonMappedTokenData = {
     [key: string]: PolygonMappedToken;
 };

package/dist/index.d.ts

@@ -9,10 +9,10 @@ import { TokenListOrFetchableTokenList } from './utils';
 export declare function chainify(l1TokenListOrPathOrUrl: TokenListOrFetchableTokenList): Promise<TokenList>;
 /**
  * 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 declare function chainifyTokenList(chainId: ChainId, l1TokenListOrPathOrUrl: TokenListOrFetchableTokenList): Promise<TokenList>;
+export declare function chainifyTokenList(l2ChainIds: Array<ChainId>, l1TokenListOrPathOrUrl: TokenListOrFetchableTokenList): Promise<TokenList>;
 /** Merges two token lists, resolving conflicts to primary list. */
 export declare function mergeTokenLists(primary: TokenList, secondary: TokenList): TokenList;

package/dist/providers/ArbitrumMappingProvider.d.ts

@@ -1,12 +1,11 @@
 import { MappingProvider } from './MappingProvider';
 import { TokenList } from '@uniswap/token-lists';
+import { GenericMappedTokenData } from '../constants/types';
 /**
  * This provider provides the l1->l2(Arbitrum) address mappings using the arbitrum SDK.
  */
 export declare class ArbitrumMappingProvider implements MappingProvider {
     l1TokenList: TokenList;
     constructor(l1TokenList: TokenList);
-    provide(): Promise<{
-        [key: string]: string | undefined;
-    }>;
+    provide(): Promise<GenericMappedTokenData>;
 }

package/dist/providers/MappingProvider.d.ts

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

package/dist/providers/OptimismMappingProvider.d.ts

@@ -1,11 +1,10 @@
 import { MappingProvider } from './MappingProvider';
+import { GenericMappedTokenData } from '../constants/types';
 /**
  * The Optimism L2 mapping (linked above) is manually maintained by the Optimism team.
  *
  * This provider provides the l1->l2(Optimism) token mappings.
  */
 export declare class OptimismMappingProvider implements MappingProvider {
-    provide(): Promise<{
-        [key: string]: string | undefined;
-    }>;
+    provide(): Promise<GenericMappedTokenData>;
 }

package/dist/providers/index.d.ts

@@ -1,3 +1,3 @@
 import { ChainId } from '../constants/chainId';
 import { TokenList } from '@uniswap/token-lists';
-export declare function buildList(chainId: ChainId, l1TokenList: TokenList): Promise<TokenList>;
+export declare function buildList(l2ChainIds: Array<ChainId>, l1TokenList: TokenList): Promise<TokenList>;

package/dist/token-list-bridge-utils.cjs.development.js

@@ -896,6 +896,7 @@ var ChainId;
   ChainId[ChainId["OPTIMISTIC_KOVAN"] = 69] = "OPTIMISTIC_KOVAN";
   ChainId[ChainId["POLYGON"] = 137] = "POLYGON";
   ChainId[ChainId["POLYGON_MUMBAI"] = 80001] = "POLYGON_MUMBAI";
+  ChainId[ChainId["CELO"] = 42220] = "CELO";
 })(ChainId || (ChainId = {}));
 
 function compareTokenInfos(t1, t2) {
@@ -1098,7 +1099,8 @@ function getRpcUrl(chainId) {
       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';
@@ -1370,8 +1372,8 @@ var OptimismMappingProvider = /*#__PURE__*/function () {
   return OptimismMappingProvider;
 }();
 
-var url = 'https://tokenmapper.api.matic.today/api/v1/mapping?';
-var params = 'map_type=[%22POS%22]&chain_id=137&limit=200&offset=';
+var url = 'https://open-api.polygon.technology/api/v1/info/all-mappings';
+var access_token = '504afd90-3228-4df9-9d88-9b4d70646101';
 /**
  * The Polygon team manually maintains the mapping via user submissions at
  * https://mapper.polygon.technology.
@@ -1386,48 +1388,34 @@ var PolygonMappingProvider = /*#__PURE__*/function () {
 
   _proto.provide = /*#__PURE__*/function () {
     var _provide = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var offset, tokens, response, _iterator, _step, token;
+      var response, tokens, _iterator, _step, token;
 
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              offset = 0;
-              tokens = {};
+              _context.next = 2;
+              return axios__default["default"].get(url, {
+                headers: {
+                  'x-access-token': access_token
+                }
+              });
 
             case 2:
-
-              _context.next = 5;
-              return axios__default["default"].get("" + url + params + offset);
-
-            case 5:
               response = _context.sent;
+              tokens = {};
 
-              if (!(response.data.message === 'success')) {
-                _context.next = 11;
-                break;
-              }
-
-              for (_iterator = _createForOfIteratorHelperLoose(response.data.data.mapping); !(_step = _iterator()).done;) {
+              for (_iterator = _createForOfIteratorHelperLoose(response.data); !(_step = _iterator()).done;) {
                 token = _step.value;
-                tokens[token.root_token.toLowerCase()] = token;
-              }
 
-              if (!(response.data.data.has_next_page === true)) {
-                _context.next = 11;
-                break;
+                if (token.isPos) {
+                  tokens[token.rootToken.toLowerCase()] = token;
+                }
               }
 
-              offset += 200;
-              return _context.abrupt("continue", 2);
-
-            case 11:
-              return _context.abrupt("break", 14);
-
-            case 14:
               return _context.abrupt("return", tokens);
 
-            case 15:
+            case 6:
             case "end":
               return _context.stop();
           }
@@ -1614,103 +1602,139 @@ var abi = [{
   type: 'event'
 }];
 
-var web3 = /*#__PURE__*/new Web3__default["default"]();
+var web3 = /*#__PURE__*/new Web3__default["default"](); // chains we support fetching mappings for (can be different than the l2ChainIds arg for buildList)
+
+var SUPPORTED_L2_CHAINS = [ChainId.ARBITRUM_ONE, ChainId.POLYGON, ChainId.OPTIMISM];
 function buildList(_x, _x2) {
   return _buildList.apply(this, arguments);
 } // using a symbol lookup contract call to check whether the token exists on the L2
 
 function _buildList() {
-  _buildList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chainId, l1TokenList) {
-    var tokenAddressMap, mappedTokens, _iterator, _step, rootToken, childToken, childTokenAddress, childTokenValid, _bridgeInfo, _bridgeInfo2, toRootExtensions, toChildExtensions, rootTokenInfo, childTokenInfo, tokenList;
+  _buildList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(l2ChainIds, l1TokenList) {
+    var multiChainedTokens, chainIdToMappingsMap, _loop, _iterator, _step, tokenList;
 
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
+    return _regeneratorRuntime.wrap(function _callee2$(_context3) {
       while (1) {
-        switch (_context.prev = _context.next) {
+        switch (_context3.prev = _context3.next) {
           case 0:
-            web3.setProvider(getRpcUrl(chainId));
-            _context.next = 3;
-            return getMappingProvider(chainId, l1TokenList).provide();
+            multiChainedTokens = [];
+            _context3.next = 3;
+            return generateTokenMappings(l2ChainIds, l1TokenList);
 
           case 3:
-            tokenAddressMap = _context.sent;
-            mappedTokens = [];
+            chainIdToMappingsMap = _context3.sent;
+            _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
+              var l1Token, chainIdToChildTokenDetailsMap, l2MappingExtension;
+              return _regeneratorRuntime.wrap(function _loop$(_context2) {
+                while (1) {
+                  switch (_context2.prev = _context2.next) {
+                    case 0:
+                      l1Token = _step.value;
+
+                      if (!(l1Token.chainId === ChainId.MAINNET)) {
+                        _context2.next = 7;
+                        break;
+                      }
+
+                      chainIdToChildTokenDetailsMap = {};
+                      l2MappingExtension = {
+                        extensions: {
+                          bridgeInfo: {}
+                        }
+                      }; // build out the extensions.bridgeInfo data containing mappings for each L2 chain
+
+                      _context2.next = 6;
+                      return Promise.all(l2ChainIds.map( /*#__PURE__*/function () {
+                        var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chainId) {
+                          return _regeneratorRuntime.wrap(function _callee$(_context) {
+                            while (1) {
+                              switch (_context.prev = _context.next) {
+                                case 0:
+                                  _context.next = 2;
+                                  return getChildTokenDetails(l1Token, chainId, chainIdToMappingsMap);
+
+                                case 2:
+                                  chainIdToChildTokenDetailsMap[chainId] = _context.sent;
+
+                                  if (chainIdToChildTokenDetailsMap[chainId].childTokenValid) {
+                                    l2MappingExtension.extensions.bridgeInfo[chainId] = {
+                                      tokenAddress: chainIdToChildTokenDetailsMap[chainId].childTokenAddress
+                                    };
+                                  }
+
+                                case 4:
+                                case "end":
+                                  return _context.stop();
+                              }
+                            }
+                          }, _callee);
+                        }));
+
+                        return function (_x10) {
+                          return _ref.apply(this, arguments);
+                        };
+                      }()));
+
+                    case 6:
+                      // build the TokenInfo objects with bridgeInfo extension
+                      l2ChainIds.concat([ChainId.MAINNET]).forEach(function (chainId) {
+                        if (chainId === ChainId.MAINNET || chainIdToChildTokenDetailsMap[chainId].childTokenValid) {
+                          var _bridgeInfo;
+
+                          var tokenInfo = chainId === ChainId.MAINNET ? _extends({}, l1Token, {
+                            extensions: Object.keys(l2MappingExtension.extensions.bridgeInfo).length > 0 ? {
+                              bridgeInfo: l2MappingExtension.extensions.bridgeInfo
+                            } : undefined
+                          }) : _extends({}, l1Token, {
+                            chainId: chainId,
+                            address: chainIdToChildTokenDetailsMap[chainId].childTokenAddress,
+                            extensions: {
+                              bridgeInfo: (_bridgeInfo = {}, _bridgeInfo[ChainId.MAINNET] = {
+                                tokenAddress: ethers.ethers.utils.getAddress(l1Token.address)
+                              }, _bridgeInfo)
+                            }
+                          });
+                          multiChainedTokens.push(tokenInfo);
+                        }
+                      });
+
+                    case 7:
+                    case "end":
+                      return _context2.stop();
+                  }
+                }
+              }, _loop);
+            });
             _iterator = _createForOfIteratorHelperLoose(l1TokenList.tokens);
 
           case 6:
             if ((_step = _iterator()).done) {
-              _context.next = 21;
+              _context3.next = 10;
               break;
             }
 
-            rootToken = _step.value;
-            childToken = tokenAddressMap[rootToken.address.toLowerCase()];
-            childTokenAddress = childToken ? ethers.ethers.utils.getAddress(typeof childToken === 'object' ? childToken.child_token : childToken) : undefined;
-            _context.t0 = Boolean;
-            _context.t1 = childTokenAddress && (typeof childToken === 'object' ? !childToken.deleted : true);
-
-            if (!_context.t1) {
-              _context.next = 16;
-              break;
-            }
-
-            _context.next = 15;
-            return hasExistingTokenContract(childTokenAddress, chainId);
-
-          case 15:
-            _context.t1 = _context.sent;
-
-          case 16:
-            _context.t2 = _context.t1;
-            childTokenValid = (0, _context.t0)(_context.t2);
-
-            if (rootToken.chainId === ChainId.MAINNET) {
-              // build extension info if available
-              toRootExtensions = childTokenValid ? {
-                extensions: {
-                  bridgeInfo: (_bridgeInfo = {}, _bridgeInfo[rootToken.chainId] = {
-                    tokenAddress: ethers.ethers.utils.getAddress(rootToken.address)
-                  }, _bridgeInfo)
-                }
-              } : {};
-              toChildExtensions = childTokenValid ? {
-                extensions: {
-                  bridgeInfo: (_bridgeInfo2 = {}, _bridgeInfo2[chainId] = {
-                    tokenAddress: childTokenAddress
-                  }, _bridgeInfo2)
-                }
-              } : {};
-              rootTokenInfo = _extends({}, rootToken, toChildExtensions);
-
-              if (childTokenValid) {
-                childTokenInfo = _extends({}, rootToken, {
-                  chainId: chainId,
-                  address: childTokenAddress
-                }, toRootExtensions);
-                mappedTokens.push(childTokenInfo);
-              }
-
-              mappedTokens.push(rootTokenInfo);
-            }
+            return _context3.delegateYield(_loop(), "t0", 8);
 
-          case 19:
-            _context.next = 6;
+          case 8:
+            _context3.next = 6;
             break;
 
-          case 21:
+          case 10:
+            // build and return final chainified token list
             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 _context.abrupt("return", tokenList);
+            return _context3.abrupt("return", tokenList);
 
-          case 23:
+          case 12:
           case "end":
-            return _context.stop();
+            return _context3.stop();
         }
       }
-    }, _callee);
+    }, _callee2);
   }));
   return _buildList.apply(this, arguments);
 }
@@ -1720,35 +1744,36 @@ function hasExistingTokenContract(_x3, _x4) {
 }
 
 function _hasExistingTokenContract() {
-  _hasExistingTokenContract = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(address, chainId) {
+  _hasExistingTokenContract = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(address, chainId) {
     var contract;
-    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+    return _regeneratorRuntime.wrap(function _callee3$(_context4) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context4.prev = _context4.next) {
           case 0:
-            _context2.prev = 0;
+            web3.setProvider(getRpcUrl(chainId));
+            _context4.prev = 1;
             contract = new web3.eth.Contract(abi, address);
-            _context2.next = 4;
+            _context4.next = 5;
             return getTokenSymbolFromContract(contract);
 
-          case 4:
-            _context2.next = 9;
+          case 5:
+            _context4.next = 10;
             break;
 
-          case 6:
-            _context2.prev = 6;
-            _context2.t0 = _context2["catch"](0);
-            return _context2.abrupt("return", false);
-
-          case 9:
-            return _context2.abrupt("return", true);
+          case 7:
+            _context4.prev = 7;
+            _context4.t0 = _context4["catch"](1);
+            return _context4.abrupt("return", false);
 
           case 10:
+            return _context4.abrupt("return", true);
+
+          case 11:
           case "end":
-            return _context2.stop();
+            return _context4.stop();
         }
       }
-    }, _callee2, null, [[0, 6]]);
+    }, _callee3, null, [[1, 7]]);
   }));
   return _hasExistingTokenContract.apply(this, arguments);
 }
@@ -1765,10 +1790,123 @@ function getMappingProvider(chainId, l1TokenList) {
       return new PolygonMappingProvider();
 
     default:
-      throw new Error("Chain " + chainId + " not supported.");
+      throw new Error("Chain " + chainId + " not supported for fetching mappings.");
   }
 }
 
+function generateTokenMappings(_x5, _x6) {
+  return _generateTokenMappings.apply(this, arguments);
+} // handles both string and object cases for childToken (Polygon mappings return object)
+
+
+function _generateTokenMappings() {
+  _generateTokenMappings = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(chainIds, l1TokenList) {
+    var chainIdToMappingsMap, _iterator2, _step2, chainId;
+
+    return _regeneratorRuntime.wrap(function _callee4$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            chainIdToMappingsMap = {};
+            _iterator2 = _createForOfIteratorHelperLoose(chainIds);
+
+          case 2:
+            if ((_step2 = _iterator2()).done) {
+              _context5.next = 10;
+              break;
+            }
+
+            chainId = _step2.value;
+
+            if (!SUPPORTED_L2_CHAINS.includes(chainId)) {
+              _context5.next = 8;
+              break;
+            }
+
+            _context5.next = 7;
+            return getMappingProvider(chainId, l1TokenList).provide();
+
+          case 7:
+            chainIdToMappingsMap[chainId] = _context5.sent;
+
+          case 8:
+            _context5.next = 2;
+            break;
+
+          case 10:
+            return _context5.abrupt("return", chainIdToMappingsMap);
+
+          case 11:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _generateTokenMappings.apply(this, arguments);
+}
+
+function getChildTokenDetails(_x7, _x8, _x9) {
+  return _getChildTokenDetails.apply(this, arguments);
+}
+
+function _getChildTokenDetails() {
+  _getChildTokenDetails = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(l1Token, chainId, chainIdToMappingsMap) {
+    var _l1Token$extensions, _l1Token$extensions$b, _l1Token$extensions$b2;
+
+    var existingMapping, childToken, childTokenAddress, childTokenValid;
+    return _regeneratorRuntime.wrap(function _callee5$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            existingMapping = l1Token == null ? void 0 : (_l1Token$extensions = l1Token.extensions) == null ? void 0 : (_l1Token$extensions$b = _l1Token$extensions.bridgeInfo) == null ? void 0 : (_l1Token$extensions$b2 = _l1Token$extensions$b[chainId]) == null ? void 0 : _l1Token$extensions$b2.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)) {
+              _context6.next = 13;
+              break;
+            }
+
+            childToken = chainIdToMappingsMap[chainId][l1Token.address.toLowerCase()];
+            childTokenAddress = childToken ? ethers.ethers.utils.getAddress(typeof childToken === 'object' ? childToken.childToken : childToken) : undefined;
+            _context6.t0 = Boolean;
+            _context6.t1 = childTokenAddress;
+
+            if (!_context6.t1) {
+              _context6.next = 10;
+              break;
+            }
+
+            _context6.next = 9;
+            return hasExistingTokenContract(childTokenAddress, chainId);
+
+          case 9:
+            _context6.t1 = _context6.sent;
+
+          case 10:
+            _context6.t2 = _context6.t1;
+            childTokenValid = (0, _context6.t0)(_context6.t2);
+            return _context6.abrupt("return", {
+              childTokenValid: childTokenValid,
+              childTokenAddress: childTokenAddress
+            });
+
+          case 13:
+            return _context6.abrupt("return", {
+              childTokenValid: !!existingMapping,
+              childTokenAddress: existingMapping
+            });
+
+          case 14:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _getChildTokenDetails.apply(this, arguments);
+}
+
 /**
  * Verifies that for each token with extensions.bridgeInfo defined, for every
  * chainId there exists a token with that chainId at the root-level of the
@@ -1842,14 +1980,14 @@ function chainify(_x) {
 }
 /**
  * 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
  */
 
 function _chainify() {
   _chainify = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(l1TokenListOrPathOrUrl) {
-    var l1TokenList, optimisimed, polygoned, arbified;
+    var l1TokenList, l2Chains, chainified;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
@@ -1859,25 +1997,16 @@ function _chainify() {
 
           case 2:
             l1TokenList = _context.sent;
-            _context.next = 5;
-            return chainifyTokenList(ChainId.OPTIMISM, l1TokenListOrPathOrUrl);
-
-          case 5:
-            optimisimed = _context.sent;
-            _context.next = 8;
-            return chainifyTokenList(ChainId.POLYGON, l1TokenListOrPathOrUrl);
-
-          case 8:
-            polygoned = _context.sent;
-            _context.next = 11;
-            return chainifyTokenList(ChainId.ARBITRUM_ONE, l1TokenListOrPathOrUrl);
+            l2Chains = [ChainId.POLYGON, ChainId.ARBITRUM_ONE, ChainId.OPTIMISM, ChainId.CELO];
+            _context.next = 6;
+            return chainifyTokenList(l2Chains, l1TokenListOrPathOrUrl);
 
-          case 11:
-            arbified = _context.sent;
+          case 6:
+            chainified = _context.sent;
             return _context.abrupt("return", mergeTokenLists(l1TokenList, // providing l1 first to make sure duplicated tokens resolve to this list
-            mergeTokenLists(mergeTokenLists(arbified, optimisimed), polygoned)));
+            chainified));
 
-          case 13:
+          case 8:
           case "end":
             return _context.stop();
         }
@@ -1893,7 +2022,7 @@ function chainifyTokenList(_x2, _x3) {
 /** Merges two token lists, resolving conflicts to primary list. */
 
 function _chainifyTokenList() {
-  _chainifyTokenList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(chainId, l1TokenListOrPathOrUrl) {
+  _chainifyTokenList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(l2ChainIds, l1TokenListOrPathOrUrl) {
     var l1TokenList, tokenList;
     return _regeneratorRuntime.wrap(function _callee2$(_context2) {
       while (1) {
@@ -1906,7 +2035,7 @@ function _chainifyTokenList() {
           case 3:
             l1TokenList = _context2.sent;
             _context2.next = 6;
-            return buildList(chainId, l1TokenList);
+            return buildList(l2ChainIds, l1TokenList);
 
           case 6:
             tokenList = _context2.sent;