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

package/dist/token-list-bridge-utils.esm.js

@@ -1,9 +1,10 @@
 import { cloneDeep, groupBy, merge } from 'lodash-es';
 import { config } from 'dotenv';
-import { providers, ethers } from 'ethers';
-import { L1GatewayRouter__factory } from '@arbitrum/sdk/dist/lib/abi/factories/L1GatewayRouter__factory';
 import { existsSync, readFileSync } from 'fs';
 import axios from 'axios';
+import { providers, ethers } from 'ethers';
+import { L1GatewayRouter__factory } from '@arbitrum/sdk/dist/lib/abi/factories/L1GatewayRouter__factory';
+import Web3 from 'web3';
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -868,175 +869,9 @@ 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 = {}));
 
-config();
-process.env.MAINNET_RPC = process.env.MAINNET_RPC || 'https://cloudflare-eth.com/';
-
-var networkID = 42161; // ref: https://github.com/OffchainLabs/arb-token-lists/blob/master/src/lib/instantiate_bridge.ts
-
-var getNetworkConfig = /*#__PURE__*/function () {
-  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-    var _yield$import, getL1Network, getL2Network, MultiCaller, l2Network, l1Network, arbProvider, ethProvider, l1MultiCaller, l2MultiCaller;
-
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return import('@arbitrum/sdk');
-
-          case 2:
-            _yield$import = _context.sent;
-            getL1Network = _yield$import.getL1Network;
-            getL2Network = _yield$import.getL2Network;
-            MultiCaller = _yield$import.MultiCaller;
-            _context.next = 8;
-            return getL2Network(networkID);
-
-          case 8:
-            l2Network = _context.sent;
-            _context.next = 11;
-            return getL1Network(l2Network.partnerChainID);
-
-          case 11:
-            l1Network = _context.sent;
-            arbProvider = new providers.JsonRpcProvider(l2Network.rpcURL);
-            ethProvider = new providers.JsonRpcProvider(l1Network.rpcURL);
-            _context.next = 16;
-            return MultiCaller.fromProvider(ethProvider);
-
-          case 16:
-            l1MultiCaller = _context.sent;
-            _context.next = 19;
-            return MultiCaller.fromProvider(arbProvider);
-
-          case 19:
-            l2MultiCaller = _context.sent;
-            return _context.abrupt("return", {
-              l1: {
-                network: l1Network,
-                provider: ethProvider,
-                multiCaller: l1MultiCaller
-              },
-              l2: {
-                network: l2Network,
-                provider: arbProvider,
-                multiCaller: l2MultiCaller
-              }
-            });
-
-          case 21:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-
-  return function getNetworkConfig() {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-var getL2TokenAddressesFromL1 = /*#__PURE__*/function () {
-  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(l1TokenAddresses, multiCaller, l1GatewayRouterAddress) {
-    var iFace;
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            iFace = L1GatewayRouter__factory.createInterface();
-            _context.next = 3;
-            return multiCaller.multiCall(l1TokenAddresses.map(function (addr) {
-              return {
-                encoder: function encoder() {
-                  return iFace.encodeFunctionData('calculateL2TokenAddress', [addr]);
-                },
-                decoder: function decoder(returnData) {
-                  return iFace.decodeFunctionResult('calculateL2TokenAddress', returnData)[0];
-                },
-                targetAddr: l1GatewayRouterAddress
-              };
-            }));
-
-          case 3:
-            return _context.abrupt("return", _context.sent);
-
-          case 4:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-
-  return function getL2TokenAddressesFromL1(_x, _x2, _x3) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-/**
- * This provider provides the l1->l2(Arbitrum) address mappings using the arbitrum SDK.
- */
-
-var ArbitrumMappingProvider = /*#__PURE__*/function () {
-  function ArbitrumMappingProvider(l1TokenList) {
-    this.l1TokenList = void 0;
-    this.l1TokenList = l1TokenList;
-  }
-
-  var _proto = ArbitrumMappingProvider.prototype;
-
-  _proto.provide = /*#__PURE__*/function () {
-    var _provide = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var tokens, _yield$getNetworkConf, l1, l2, tokenAddresses, l2AddressesFromL1;
-
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              tokens = {};
-              _context.next = 3;
-              return getNetworkConfig();
-
-            case 3:
-              _yield$getNetworkConf = _context.sent;
-              l1 = _yield$getNetworkConf.l1;
-              l2 = _yield$getNetworkConf.l2;
-              tokenAddresses = this.l1TokenList.tokens.map(function (token) {
-                return token.address.toLowerCase();
-              });
-              _context.next = 9;
-              return getL2TokenAddressesFromL1(tokenAddresses, l1.multiCaller, l2.network.tokenBridge.l1GatewayRouter);
-
-            case 9:
-              l2AddressesFromL1 = _context.sent;
-              tokens = tokenAddresses.reduce(function (obj, key, index) {
-                var _extends2;
-
-                return _extends({}, obj, (_extends2 = {}, _extends2[key] = l2AddressesFromL1[index], _extends2));
-              }, {});
-              return _context.abrupt("return", tokens);
-
-            case 12:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee, this);
-    }));
-
-    function provide() {
-      return _provide.apply(this, arguments);
-    }
-
-    return provide;
-  }();
-
-  return ArbitrumMappingProvider;
-}();
-
 function compareTokenInfos(t1, t2) {
   if (t1.chainId === t2.chainId) {
     return t1.symbol.toLowerCase() < t2.symbol.toLowerCase() ? -1 : 1;
@@ -1231,6 +1066,229 @@ var isTokenList = function isTokenList(obj) {
     throw new Error('tokenlist typeguard error: token missing required key');
   }
 };
+function getRpcUrl(chainId) {
+  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';
+  }
+
+  throw new Error('Unsupported ChainId');
+}
+function getTokenSymbolFromContract(_x6) {
+  return _getTokenSymbolFromContract.apply(this, arguments);
+}
+
+function _getTokenSymbolFromContract() {
+  _getTokenSymbolFromContract = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(tokenContract) {
+    var symbol;
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 2;
+            return Promise.all([tokenContract.methods.symbol().call()]);
+
+          case 2:
+            symbol = _context6.sent;
+            return _context6.abrupt("return", symbol);
+
+          case 4:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _getTokenSymbolFromContract.apply(this, arguments);
+}
+
+var _process$env, _process$env$MAINNET_;
+
+config();
+(_process$env$MAINNET_ = (_process$env = process.env).MAINNET_RPC) != null ? _process$env$MAINNET_ : _process$env.MAINNET_RPC = /*#__PURE__*/getRpcUrl(ChainId.MAINNET);
+
+var networkID = 42161; // ref: https://github.com/OffchainLabs/arb-token-lists/blob/master/src/lib/instantiate_bridge.ts
+
+var getNetworkConfig = /*#__PURE__*/function () {
+  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _yield$import, getL1Network, getL2Network, MultiCaller, l2Network, l1Network, arbProvider, ethProvider, l1MultiCaller, l2MultiCaller;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return import('@arbitrum/sdk');
+
+          case 2:
+            _yield$import = _context.sent;
+            getL1Network = _yield$import.getL1Network;
+            getL2Network = _yield$import.getL2Network;
+            MultiCaller = _yield$import.MultiCaller;
+            _context.next = 8;
+            return getL2Network(networkID);
+
+          case 8:
+            l2Network = _context.sent;
+            _context.next = 11;
+            return getL1Network(l2Network.partnerChainID);
+
+          case 11:
+            l1Network = _context.sent;
+            arbProvider = new providers.JsonRpcProvider(l2Network.rpcURL);
+            ethProvider = new providers.JsonRpcProvider(l1Network.rpcURL);
+            _context.next = 16;
+            return MultiCaller.fromProvider(ethProvider);
+
+          case 16:
+            l1MultiCaller = _context.sent;
+            _context.next = 19;
+            return MultiCaller.fromProvider(arbProvider);
+
+          case 19:
+            l2MultiCaller = _context.sent;
+            return _context.abrupt("return", {
+              l1: {
+                network: l1Network,
+                provider: ethProvider,
+                multiCaller: l1MultiCaller
+              },
+              l2: {
+                network: l2Network,
+                provider: arbProvider,
+                multiCaller: l2MultiCaller
+              }
+            });
+
+          case 21:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getNetworkConfig() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var getL2TokenAddressesFromL1 = /*#__PURE__*/function () {
+  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(l1TokenAddresses, multiCaller, l1GatewayRouterAddress) {
+    var iFace;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            iFace = L1GatewayRouter__factory.createInterface();
+            _context.next = 3;
+            return multiCaller.multiCall(l1TokenAddresses.map(function (addr) {
+              return {
+                encoder: function encoder() {
+                  return iFace.encodeFunctionData('calculateL2TokenAddress', [addr]);
+                },
+                decoder: function decoder(returnData) {
+                  return iFace.decodeFunctionResult('calculateL2TokenAddress', returnData)[0];
+                },
+                targetAddr: l1GatewayRouterAddress
+              };
+            }));
+
+          case 3:
+            return _context.abrupt("return", _context.sent);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getL2TokenAddressesFromL1(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+/**
+ * This provider provides the l1->l2(Arbitrum) address mappings using the arbitrum SDK.
+ */
+
+var ArbitrumMappingProvider = /*#__PURE__*/function () {
+  function ArbitrumMappingProvider(l1TokenList) {
+    this.l1TokenList = void 0;
+    this.l1TokenList = l1TokenList;
+  }
+
+  var _proto = ArbitrumMappingProvider.prototype;
+
+  _proto.provide = /*#__PURE__*/function () {
+    var _provide = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var tokens, _yield$getNetworkConf, l1, l2, tokenAddresses, l2AddressesFromL1;
+
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              tokens = {};
+              _context.next = 3;
+              return getNetworkConfig();
+
+            case 3:
+              _yield$getNetworkConf = _context.sent;
+              l1 = _yield$getNetworkConf.l1;
+              l2 = _yield$getNetworkConf.l2;
+              tokenAddresses = this.l1TokenList.tokens.map(function (token) {
+                return token.address.toLowerCase();
+              });
+              _context.next = 9;
+              return getL2TokenAddressesFromL1(tokenAddresses, l1.multiCaller, l2.network.tokenBridge.l1GatewayRouter);
+
+            case 9:
+              l2AddressesFromL1 = _context.sent;
+              tokens = tokenAddresses.reduce(function (obj, key, index) {
+                var _extends2;
+
+                return _extends({}, obj, (_extends2 = {}, _extends2[key] = l2AddressesFromL1[index], _extends2));
+              }, {});
+              return _context.abrupt("return", tokens);
+
+            case 12:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function provide() {
+      return _provide.apply(this, arguments);
+    }
+
+    return provide;
+  }();
+
+  return ArbitrumMappingProvider;
+}();
 
 var optimismTokenListURL = 'https://raw.githubusercontent.com/' + 'ethereum-optimism/ethereum-optimism.github.io/2138386277e4156d159615d1840882cecc398437/optimism.tokenlist.json';
 /**
@@ -1362,78 +1420,351 @@ var PolygonMappingProvider = /*#__PURE__*/function () {
   return PolygonMappingProvider;
 }();
 
+var abi = [{
+  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'
+}];
+
+var web3 = /*#__PURE__*/new Web3(); // 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, 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:
-            _context.next = 2;
-            return getMappingProvider(chainId, l1TokenList).provide();
+            multiChainedTokens = [];
+            _context3.next = 3;
+            return generateTokenMappings(l2ChainIds, l1TokenList);
 
-          case 2:
-            tokenAddressMap = _context.sent;
-            mappedTokens = [];
-
-            for (_iterator = _createForOfIteratorHelperLoose(l1TokenList.tokens); !(_step = _iterator()).done;) {
-              rootToken = _step.value;
-              childToken = tokenAddressMap[rootToken.address.toLowerCase()];
-              childTokenValid = Boolean(childToken && (typeof childToken === 'object' ? !childToken.deleted : true));
-
-              if (rootToken.chainId === ChainId.MAINNET) {
-                // build extension info if available
-                toRootExtensions = childTokenValid ? {
-                  extensions: {
-                    bridgeInfo: (_bridgeInfo = {}, _bridgeInfo[rootToken.chainId] = {
-                      tokenAddress: ethers.utils.getAddress(rootToken.address)
-                    }, _bridgeInfo)
-                  }
-                } : {};
-                toChildExtensions = childTokenValid ? {
-                  extensions: {
-                    bridgeInfo: (_bridgeInfo2 = {}, _bridgeInfo2[chainId] = {
-                      tokenAddress: ethers.utils.getAddress(typeof childToken === 'object' ? childToken.child_token : childToken)
-                    }, _bridgeInfo2)
+          case 3:
+            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.utils.getAddress(l1Token.address)
+                              }, _bridgeInfo)
+                            }
+                          });
+                          multiChainedTokens.push(tokenInfo);
+                        }
+                      });
+
+                    case 7:
+                    case "end":
+                      return _context2.stop();
                   }
-                } : {};
-                rootTokenInfo = _extends({}, rootToken, toChildExtensions);
-
-                if (childTokenValid) {
-                  childTokenInfo = _extends({}, rootToken, {
-                    chainId: chainId,
-                    address: ethers.utils.getAddress(typeof childToken === 'object' ? childToken.child_token : childToken)
-                  }, toRootExtensions);
-                  mappedTokens.push(childTokenInfo);
                 }
+              }, _loop);
+            });
+            _iterator = _createForOfIteratorHelperLoose(l1TokenList.tokens);
 
-                mappedTokens.push(rootTokenInfo);
-              }
+          case 6:
+            if ((_step = _iterator()).done) {
+              _context3.next = 10;
+              break;
             }
 
+            return _context3.delegateYield(_loop(), "t0", 8);
+
+          case 8:
+            _context3.next = 6;
+            break;
+
+          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 7:
+          case 12:
           case "end":
-            return _context.stop();
+            return _context3.stop();
         }
       }
-    }, _callee);
+    }, _callee2);
   }));
   return _buildList.apply(this, arguments);
 }
 
+function hasExistingTokenContract(_x3, _x4) {
+  return _hasExistingTokenContract.apply(this, arguments);
+}
+
+function _hasExistingTokenContract() {
+  _hasExistingTokenContract = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(address, chainId) {
+    var contract;
+    return _regeneratorRuntime.wrap(function _callee3$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            web3.setProvider(getRpcUrl(chainId));
+            _context4.prev = 1;
+            contract = new web3.eth.Contract(abi, address);
+            _context4.next = 5;
+            return getTokenSymbolFromContract(contract);
+
+          case 5:
+            _context4.next = 10;
+            break;
+
+          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 _context4.stop();
+        }
+      }
+    }, _callee3, null, [[1, 7]]);
+  }));
+  return _hasExistingTokenContract.apply(this, arguments);
+}
+
 function getMappingProvider(chainId, l1TokenList) {
   switch (chainId) {
     case ChainId.ARBITRUM_ONE:
@@ -1446,10 +1777,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.utils.getAddress(typeof childToken === 'object' ? childToken.child_token : childToken) : undefined;
+            _context6.t0 = Boolean;
+            _context6.t1 = childTokenAddress && (typeof childToken === 'object' ? !childToken.deleted : true);
+
+            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
@@ -1523,14 +1967,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) {
@@ -1540,25 +1984,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);
+            l2Chains = [ChainId.POLYGON, ChainId.ARBITRUM_ONE, ChainId.OPTIMISM, ChainId.CELO];
+            _context.next = 6;
+            return chainifyTokenList(l2Chains, l1TokenListOrPathOrUrl);
 
-          case 8:
-            polygoned = _context.sent;
-            _context.next = 11;
-            return chainifyTokenList(ChainId.ARBITRUM_ONE, 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();
         }
@@ -1574,7 +2009,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) {
@@ -1587,7 +2022,7 @@ function _chainifyTokenList() {
           case 3:
             l1TokenList = _context2.sent;
             _context2.next = 6;
-            return buildList(chainId, l1TokenList);
+            return buildList(l2ChainIds, l1TokenList);
 
           case 6:
             tokenList = _context2.sent;