@imtbl/sdk 0.27.10 → 0.27.12

package/dist/checkout_sdk.js

@@ -14685,8 +14685,11 @@ function poolEquals(poolA, poolB) {
     return (poolA === poolB ||
         (poolA.token0.equals(poolB.token0) && poolA.token1.equals(poolB.token1) && poolA.fee === poolB.fee));
 }
-async function getERC20Decimals(tokenAddress, provider) {
-    const decimalsFunctionSig = ethers.utils.id('decimals()').substring(0, 10);
+const decimalsFunctionSig = ethers.utils.id('decimals()').substring(0, 10);
+async function getTokenDecimals(tokenAddress, provider, nativeToken) {
+    if (tokenAddress === 'native') {
+        return nativeToken.decimals;
+    }
     try {
         const decimalsResult = await provider.call({
             to: tokenAddress,
@@ -14714,6 +14717,7 @@ function isValidNonZeroAddress(address) {
         return false;
     }
 }
+const isValidTokenLiteral = (address) => address === 'native' ? true : isValidNonZeroAddress(address);
 const erc20ToUniswapToken = (token) => 
 // eslint-disable-next-line implicit-arrow-linebreak
 new Uniswap.Token(token.chainId, token.address, token.decimals, token.symbol, token.name);
@@ -15168,12 +15172,13 @@ const getUnsignedERC20ApproveTransaction = (ownerAddress, tokenAmount, spenderAd
         from: ownerAddress,
     };
 };
-const prepareApproval = (tradeType, amountSpecified, amountWithSlippage, contracts, secondaryFees) => {
-    const amountOfTokenIn = tradeType === TradeType.EXACT_INPUT ? amountSpecified : amountWithSlippage;
-    const spender = secondaryFees.length === 0
-        ? contracts.routerAddress
-        : contracts.secondaryFeeAddress;
-    return { spender, amount: amountOfTokenIn };
+const prepareApproval = (tradeType, userSpecifiedAmount, quotedAmountWithSlippage, contracts, secondaryFees) => {
+    const amountInToApprove = tradeType === TradeType.EXACT_INPUT ? userSpecifiedAmount : quotedAmountWithSlippage;
+    if (!isERC20Amount(amountInToApprove)) {
+        return null;
+    }
+    const spender = secondaryFees.length === 0 ? contracts.routerAddress : contracts.secondaryFeeAddress;
+    return { spender, amount: amountInToApprove };
 };
 /**
  * Get an unsigned approval transaction if needed
@@ -15218,6 +15223,38 @@ const getApproval = async (provider, ownerAddress, preparedApproval, gasPrice) =
     };
 };
 
+const canUnwrapToken = (token) => token.type === 'native';
+class NativeTokenService {
+    nativeToken;
+    wrappedToken;
+    constructor(nativeToken, wrappedToken) {
+        this.nativeToken = nativeToken;
+        this.wrappedToken = wrappedToken;
+    }
+    wrapAmount(amount) {
+        if (!canUnwrapToken(amount.token)) {
+            throw new Error(`cannot wrap non-native token: ${amount.token.address}`);
+        }
+        return newAmount(amount.value, this.wrappedToken);
+    }
+    unwrapAmount(amount) {
+        const isWrappedToken = amount.token.address.toLowerCase() !== this.wrappedToken.address.toLowerCase();
+        if (isWrappedToken) {
+            throw new Error(`cannot unwrap non-wrapped token ${amount.token.address}`);
+        }
+        return newAmount(amount.value, this.nativeToken);
+    }
+    maybeWrapToken(token) {
+        if (canUnwrapToken(token)) {
+            return this.wrappedToken;
+        }
+        return token;
+    }
+    maybeWrapAmount(amount) {
+        return newAmount(amount.value, this.maybeWrapToken(amount.token));
+    }
+}
+
 // slippageToPercent takes the slippage as a percentage (e.g. 0.1) and
 // converts it to the Uniswap equivalent type
 const slippageToFraction = (slippage) => {
@@ -15237,11 +15274,11 @@ const slippageToFraction = (slippage) => {
     return new Percent(numerator, denominator);
 };
 
-function getQuoteAmountFromTradeType(tradeInfo) {
-    if (tradeInfo.tradeType === TradeType.EXACT_INPUT) {
-        return tradeInfo.amountOut;
+function getQuoteAmountFromTradeType(routerQuote) {
+    if (routerQuote.tradeType === TradeType.EXACT_INPUT) {
+        return routerQuote.amountOut;
     }
-    return tradeInfo.amountIn;
+    return routerQuote.amountIn;
 }
 function applySlippage(tradeType, amount, slippage) {
     const slippageTolerance = slippageToFraction(slippage);
@@ -15250,6 +15287,18 @@ function applySlippage(tradeType, amount, slippage) {
     const amountWithSlippage = maybeInverted.multiply(amount.toString()).quotient;
     return ethers.BigNumber.from(amountWithSlippage.toString());
 }
+const prepareUserQuote = (nativeTokenService, routerQuote, slippage, tokenOfQuotedAmount) => {
+    const erc20QuoteAmount = getQuoteAmountFromTradeType(routerQuote);
+    // If the quote amount is the native token, we need to unwrap it if the user originally specified the native token
+    const quotedAmount = canUnwrapToken(tokenOfQuotedAmount)
+        ? nativeTokenService.unwrapAmount(erc20QuoteAmount)
+        : erc20QuoteAmount;
+    const quotedAmountWithMaxSlippage = newAmount(applySlippage(routerQuote.tradeType, quotedAmount.value, slippage), tokenOfQuotedAmount);
+    return {
+        quotedAmount,
+        quotedAmountWithMaxSlippage,
+    };
+};
 function getOurQuoteReqAmount(amountSpecified, // the amount specified by the user, either exactIn or exactOut
 fees, tradeType, nativeTokenService) {
     if (tradeType === TradeType.EXACT_OUTPUT) {
@@ -15317,39 +15366,6 @@ class Fees {
     }
 }
 
-class NativeTokenService {
-    nativeToken;
-    wrappedToken;
-    constructor(nativeToken, wrappedToken) {
-        this.nativeToken = nativeToken;
-        this.wrappedToken = wrappedToken;
-    }
-    wrapAmount(amount) {
-        if (!this.isNativeToken(amount.token)) {
-            throw new Error(`cannot wrap non-native token: ${amount.token.address}`);
-        }
-        return newAmount(amount.value, this.wrappedToken);
-    }
-    unwrapAmount(amount) {
-        if (amount.token !== this.wrappedToken) {
-            throw new Error(`cannot unwrap non-wrapped token ${amount.token.address}`);
-        }
-        return newAmount(amount.value, this.nativeToken);
-    }
-    maybeWrapToken(token) {
-        if (this.isNativeToken(token)) {
-            return this.wrappedToken;
-        }
-        return token;
-    }
-    maybeWrapAmount(amount) {
-        return newAmount(amount.value, this.maybeWrapToken(amount.token));
-    }
-    isNativeToken(token) {
-        return token === this.nativeToken;
-    }
-}
-
 const IMMUTABLE_TESTNET_RPC_URL = 'https://rpc.testnet.immutable.com';
 const IMMUTABLE_TESTNET_CHAIN_ID = 13472;
 const TIMX_IMMUTABLE_TESTNET = {
@@ -15381,7 +15397,9 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
         recipient: fee.recipient,
     }));
     if (trade.tradeType === TradeType.EXACT_INPUT) {
-        return secondaryFeeContract.encodeFunctionData('exactInputSingleWithSecondaryFee', [secondaryFeeValues, {
+        return secondaryFeeContract.encodeFunctionData('exactInputSingleWithSecondaryFee', [
+            secondaryFeeValues,
+            {
                 tokenIn: route.tokenPath[0].address,
                 tokenOut: route.tokenPath[1].address,
                 fee: route.pools[0].fee,
@@ -15389,9 +15407,12 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
                 amountIn,
                 amountOutMinimum: amountOut,
                 sqrtPriceLimitX96: 0,
-            }]);
+            },
+        ]);
     }
-    return secondaryFeeContract.encodeFunctionData('exactOutputSingleWithSecondaryFee', [secondaryFeeValues, {
+    return secondaryFeeContract.encodeFunctionData('exactOutputSingleWithSecondaryFee', [
+        secondaryFeeValues,
+        {
             tokenIn: route.tokenPath[0].address,
             tokenOut: route.tokenPath[1].address,
             fee: route.pools[0].fee,
@@ -15399,7 +15420,8 @@ function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountI
             amountInMaximum: amountIn,
             amountOut,
             sqrtPriceLimitX96: 0,
-        }]);
+        },
+    ]);
 }
 function buildSwapParametersForMultiPoolSwap(fromAddress, trade, route, amountIn, amountOut, secondaryFees, secondaryFeeContract) {
     const path = encodeRouteToPath(route, trade.tradeType === TradeType.EXACT_OUTPUT);
@@ -15408,19 +15430,25 @@ function buildSwapParametersForMultiPoolSwap(fromAddress, trade, route, amountIn
         recipient: fee.recipient,
     }));
     if (trade.tradeType === TradeType.EXACT_INPUT) {
-        return secondaryFeeContract.encodeFunctionData('exactInputWithSecondaryFee', [secondaryFeeValues, {
+        return secondaryFeeContract.encodeFunctionData('exactInputWithSecondaryFee', [
+            secondaryFeeValues,
+            {
                 path,
                 recipient: fromAddress,
                 amountIn,
                 amountOutMinimum: amountOut,
-            }]);
+            },
+        ]);
     }
-    return secondaryFeeContract.encodeFunctionData('exactOutputWithSecondaryFee', [secondaryFeeValues, {
+    return secondaryFeeContract.encodeFunctionData('exactOutputWithSecondaryFee', [
+        secondaryFeeValues,
+        {
             path,
             recipient: fromAddress,
             amountInMaximum: amountIn,
             amountOut,
-        }]);
+        },
+    ]);
 }
 /**
  * Builds swap parameters
@@ -15445,7 +15473,10 @@ function buildSwapParameters(fromAddress, trade, options, secondaryFees, seconda
 function createSwapCallParametersWithFees(trade, fromAddress, swapOptions, secondaryFees) {
     const secondaryFeeContract = SecondaryFee__factory.createInterface();
     const swapWithFeesCalldata = buildSwapParameters(fromAddress, trade, swapOptions, secondaryFees, secondaryFeeContract);
-    return secondaryFeeContract.encodeFunctionData(multicallWithDeadlineFunctionSignature, [swapOptions.deadlineOrPreviousBlockhash, [swapWithFeesCalldata]]);
+    return secondaryFeeContract.encodeFunctionData(multicallWithDeadlineFunctionSignature, [
+        swapOptions.deadlineOrPreviousBlockhash,
+        [swapWithFeesCalldata],
+    ]);
 }
 function createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, secondaryFees) {
     // Create an unchecked trade to be used in generating swap parameters.
@@ -15485,7 +15516,7 @@ function getSwap(adjustedQuote, fromAddress, slippage, deadline, peripheryRouter
 const adjustAmountIn = (ourQuote, amountSpecified, fees, nativeTokenService) => {
     if (ourQuote.tradeType === TradeType.EXACT_OUTPUT) {
         // when doing exact output, calculate the fees based on the amountIn
-        const amountToAdd = nativeTokenService.isNativeToken(fees.token)
+        const amountToAdd = canUnwrapToken(fees.token)
             ? nativeTokenService.unwrapAmount(ourQuote.amountIn)
             : ourQuote.amountIn;
         fees.addAmount(amountToAdd);
@@ -15602,8 +15633,8 @@ class ExchangeConfiguration {
 }
 
 const toPublicQuote = (amount, amountWithMaxSlippage, slippage, fees) => ({
-    amount,
-    amountWithMaxSlippage,
+    amount: toPublicAmount(amount),
+    amountWithMaxSlippage: toPublicAmount(amountWithMaxSlippage),
     slippage,
     fees: fees.withAmounts().map((fee) => ({
         ...fee,
@@ -15638,8 +15669,8 @@ class Exchange {
     }
     static validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress) {
         assert(isValidNonZeroAddress(fromAddress), new InvalidAddressError('invalid from address'));
-        assert(isValidNonZeroAddress(tokenInAddress), new InvalidAddressError('invalid token in address'));
-        assert(isValidNonZeroAddress(tokenOutAddress), new InvalidAddressError('invalid token out address'));
+        assert(isValidTokenLiteral(tokenInAddress), new InvalidAddressError('invalid token in address'));
+        assert(isValidTokenLiteral(tokenOutAddress), new InvalidAddressError('invalid token out address'));
         assert(tokenInAddress.toLocaleLowerCase() !== tokenOutAddress.toLocaleLowerCase(), new DuplicateAddressesError());
         assert(maxHops <= MAX_MAX_HOPS, new InvalidMaxHopsError('max hops must be less than or equal to 10'));
         assert(maxHops >= MIN_MAX_HOPS, new InvalidMaxHopsError('max hops must be greater than or equal to 1'));
@@ -15657,61 +15688,63 @@ class Exchange {
         }
         return this.secondaryFees;
     }
-    async getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, amount, slippagePercent, maxHops, deadline, tradeType) {
-        Exchange.validate(tokenInAddress, tokenOutAddress, maxHops, slippagePercent, fromAddress);
+    parseTokenLiteral(tokenLiteral, decimals) {
+        if (tokenLiteral === 'native') {
+            return this.nativeToken;
+        }
+        return {
+            type: 'erc20',
+            address: tokenLiteral,
+            chainId: this.chainId,
+            decimals,
+        };
+    }
+    async getUnsignedSwapTx(fromAddress, tokenInLiteral, tokenOutLiteral, amount, slippagePercent, maxHops, deadline, tradeType) {
+        Exchange.validate(tokenInLiteral, tokenOutLiteral, maxHops, slippagePercent, fromAddress);
         // get the decimals of the tokens that will be swapped
         const [tokenInDecimals, tokenOutDecimals, secondaryFees] = await Promise.all([
-            getERC20Decimals(tokenInAddress, this.provider),
-            getERC20Decimals(tokenOutAddress, this.provider),
+            getTokenDecimals(tokenInLiteral, this.provider, this.nativeToken),
+            getTokenDecimals(tokenOutLiteral, this.provider, this.nativeToken),
             this.getSecondaryFees(),
         ]);
-        const tokenIn = {
-            type: 'erc20',
-            address: tokenInAddress,
-            chainId: this.chainId,
-            decimals: tokenInDecimals,
-        };
-        const tokenOut = {
-            type: 'erc20',
-            address: tokenOutAddress,
-            chainId: this.chainId,
-            decimals: tokenOutDecimals,
-        };
+        const tokenIn = this.parseTokenLiteral(tokenInLiteral, tokenInDecimals);
+        const tokenOut = this.parseTokenLiteral(tokenOutLiteral, tokenOutDecimals);
         // determine which amount was specified for the swap from the TradeType
         const [tokenSpecified, otherToken] = tradeType === TradeType.EXACT_INPUT ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
         const amountSpecified = newAmount(amount, tokenSpecified);
         const fees = new Fees(secondaryFees, tokenIn);
         const ourQuoteReqAmount = getOurQuoteReqAmount(amountSpecified, fees, tradeType, this.nativeTokenService);
-        // get quote and gas details
+        // Quotes will always use ERC20s. If the user-specified token is Native, we use the Wrapped Native Token pool
         const [ourQuote, gasPrice] = await Promise.all([
-            this.router.findOptimalRoute(ourQuoteReqAmount, otherToken, tradeType, maxHops),
+            this.router.findOptimalRoute(ourQuoteReqAmount, this.nativeTokenService.maybeWrapToken(otherToken), tradeType, maxHops),
             fetchGasPrice(this.provider, this.nativeToken),
         ]);
         const adjustedQuote = adjustQuoteWithFees(ourQuote, amountSpecified, fees, this.nativeTokenService);
         const swap = getSwap(adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees, this.nativeTokenService);
-        const quotedAmount = getQuoteAmountFromTradeType(adjustedQuote);
-        const amountWithMaxSlippage = newAmount(applySlippage(adjustedQuote.tradeType, quotedAmount.value, slippagePercent), otherToken);
-        const preparedApproval = prepareApproval(tradeType, amountSpecified, amountWithMaxSlippage, {
+        const { quotedAmount, quotedAmountWithMaxSlippage } = prepareUserQuote(this.nativeTokenService, adjustedQuote, slippagePercent, otherToken);
+        const preparedApproval = prepareApproval(tradeType, amountSpecified, quotedAmountWithMaxSlippage, {
             routerAddress: this.routerContractAddress,
             secondaryFeeAddress: this.secondaryFeeContractAddress,
         }, secondaryFees);
         // preparedApproval always uses the tokenIn address because we are always selling the tokenIn
-        const approval = await getApproval(this.provider, fromAddress, preparedApproval, gasPrice);
-        const quote = toPublicQuote(quotedAmount, amountWithMaxSlippage, slippagePercent, fees);
+        const approval = preparedApproval
+            ? await getApproval(this.provider, fromAddress, preparedApproval, gasPrice)
+            : null;
+        const quote = toPublicQuote(quotedAmount, quotedAmountWithMaxSlippage, slippagePercent, fees);
         return { quote, approval, swap };
     }
     /**
      * Get the unsigned swap transaction given the amount to sell.
      * Includes quote details for the swap.
      *
-     * @param {string} fromAddress The public address that will sign and submit the transaction.
-     * @param {string} tokenInAddress Token address to sell.
-     * @param {string} tokenOutAddress Token address to buy.
-     * @param {ethers.BigNumberish} amountIn Amount to sell.
-     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0.
-     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2.
-     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes.
-     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap.
+     * @param {string} fromAddress The public address that will sign and submit the transaction
+     * @param {string} tokenInAddress Token address or 'native' to sell
+     * @param {string} tokenOutAddress Token address or 'native' to buy
+     * @param {ethers.BigNumberish} amountIn Amount to sell in the smallest unit of the token-in
+     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0
+     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2
+     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes
+     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap
      */
     async getUnsignedSwapTxFromAmountIn(fromAddress, tokenInAddress, tokenOutAddress, amountIn, slippagePercent = DEFAULT_SLIPPAGE, maxHops = DEFAULT_MAX_HOPS, deadline = DEFAULT_DEADLINE) {
         return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.BigNumber.from(amountIn), slippagePercent, maxHops, deadline, TradeType.EXACT_INPUT);
@@ -15720,14 +15753,14 @@ class Exchange {
      * Get the unsigned swap transaction given the amount to buy.
      * Includes quote details for the swap.
      *
-     * @param {string} fromAddress The public address that will sign and submit the transaction.
-     * @param {string} tokenInAddress Token address to sell.
-     * @param {string} tokenOutAddress Token address to buy.
-     * @param {ethers.BigNumberish} amountOut Amount to buy.
-     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0.
-     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2.
-     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes.
-     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap.
+     * @param {string} fromAddress The public address that will sign and submit the transaction
+     * @param {string} tokenInAddress ERC20 contract address or 'native' to sell
+     * @param {string} tokenOutAddress ERC20 contract address or 'native' to buy
+     * @param {ethers.BigNumberish} amountOut Amount to buy in the smallest unit of the token-out
+     * @param {number} slippagePercent (optional) The percentage of slippage tolerance. Default = 0.1. Max = 50. Min = 0
+     * @param {number} maxHops (optional) Maximum hops allowed in optimal route. Default is 2
+     * @param {number} deadline (optional) Latest time swap can execute. Default is 15 minutes
+     * @return {TransactionResponse} The result containing the unsigned transaction and details of the swap
      */
     async getUnsignedSwapTxFromAmountOut(fromAddress, tokenInAddress, tokenOutAddress, amountOut, slippagePercent = DEFAULT_SLIPPAGE, maxHops = DEFAULT_MAX_HOPS, deadline = DEFAULT_DEADLINE) {
         return await this.getUnsignedSwapTx(fromAddress, tokenInAddress, tokenOutAddress, ethers.BigNumber.from(amountOut), slippagePercent, maxHops, deadline, TradeType.EXACT_OUTPUT);
@@ -16154,7 +16187,7 @@ class OrdersService {
      * @returns ListListingsResult OK response.
      * @throws ApiError
      */
-    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, pageSize, sortBy, sortDirection, pageCursor, }) {
+    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/v1/chains/{chain_name}/orders/listings',
@@ -16166,6 +16199,7 @@ class OrdersService {
                 'sell_item_contract_address': sellItemContractAddress,
                 'buy_item_contract_address': buyItemContractAddress,
                 'sell_item_token_id': sellItemTokenId,
+                'from_updated_at': fromUpdatedAt,
                 'page_size': pageSize,
                 'sort_by': sortBy,
                 'sort_direction': sortDirection,
@@ -16249,7 +16283,7 @@ class OrdersService {
      * @returns ListTradeResult OK response.
      * @throws ApiError
      */
-    listTrades({ chainName, accountAddress, pageSize, sortBy, sortDirection, pageCursor, }) {
+    listTrades({ chainName, accountAddress, fromIndexedAt, pageSize, sortBy, sortDirection, pageCursor, }) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/v1/chains/{chain_name}/trades',
@@ -16258,6 +16292,7 @@ class OrdersService {
             },
             query: {
                 'account_address': accountAddress,
+                'from_indexed_at': fromIndexedAt,
                 'page_size': pageSize,
                 'sort_by': sortBy,
                 'sort_direction': sortDirection,
@@ -16323,6 +16358,16 @@ var CancelledOrderStatus;
     })(CancelledOrderStatus.cancellation_type || (CancelledOrderStatus.cancellation_type = {}));
 })(CancelledOrderStatus || (CancelledOrderStatus = {}));
 
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+var FailedOrderCancellation;
+(function (FailedOrderCancellation) {
+    (function (reason_code) {
+        reason_code["ALREADY_FILLED"] = "ALREADY_FILLED";
+    })(FailedOrderCancellation.reason_code || (FailedOrderCancellation.reason_code = {}));
+})(FailedOrderCancellation || (FailedOrderCancellation = {}));
+
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -20554,7 +20599,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.10',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.12',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -21180,6 +21225,14 @@ const $d85ad1457a3f1a83$export$fc55ed5a42b458ba = {
     [($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_MAINNET]: {
         url: "https://explorer.mainnet.immutable.com",
         nativeToken: $d85ad1457a3f1a83$export$6f24f3cef7d501c4.get(($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_MAINNET).nativeCurrency
+    },
+    [($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA]: {
+        url: "https://eth-sepolia.blockscout.com",
+        nativeToken: $d85ad1457a3f1a83$export$3e81fc0987227f10.get(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA).nativeCurrency
+    },
+    [($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM]: {
+        url: "https://eth.blockscout.com/",
+        nativeToken: $d85ad1457a3f1a83$export$6f24f3cef7d501c4.get(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM).nativeCurrency
     }
 };
 const $d85ad1457a3f1a83$export$db5daa1b5156ccfe = [
@@ -21779,6 +21832,7 @@ const $efe60cea83bfc4e8$export$473cec51305fdae8 = async (config, { type: type =
 
 
 
+
 const $fd8a8472dcc3ec2b$var$CACHE_DATA_TTL = 60; // seconds
 class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
     url;
@@ -21912,6 +21966,20 @@ class $fd8a8472dcc3ec2b$export$ef140a6b05dfc786 {
 
 
 
+const $458d407830d66110$export$e6a390ea6399b7d8 = (config, debugString, seconds)=>{
+    // eslint-disable-next-line no-console
+    if (!config.isProduction) console.debug(debugString, seconds);
+};
+const $458d407830d66110$export$5280dbcb91c8b391 = async (config, debugString, promise)=>{
+    const startTime = performance.now();
+    const result = await promise;
+    const endTime = performance.now();
+    const elapsedTimeInSeconds = (endTime - startTime) / 1000;
+    $458d407830d66110$export$e6a390ea6399b7d8(config, debugString, elapsedTimeInSeconds);
+    return result;
+};
+
+
 const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (config, web3Provider, walletAddress)=>await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
         const networkInfo = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(config, web3Provider);
         if (!networkInfo.isSupported) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${networkInfo.chainId} is not a supported chain`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR, {
@@ -21951,18 +22019,23 @@ async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(web3Provider, walletAdd
         type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_ERC20_BALANCE_ERROR
     });
 }
-// Blockscout client singleton
-let $1564e43dde50bb61$var$blockscoutClient;
-const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId, rename)=>{
+// Blockscout client singleton per chain id
+const $1564e43dde50bb61$var$blockscoutClientMap = new Map();
+const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId, filterTokens)=>{
     // Shuffle the mapping of the tokens configuration so it is a hashmap
     // for faster access to tokens config objects.
-    const mapRename = Object.assign({}, ...rename.map((t)=>({
+    const shouldFilter = filterTokens.length > 0;
+    const mapFilterTokens = Object.assign({}, ...filterTokens.map((t)=>({
             [t.address || ""]: t
         })));
-    // Ensure singleton is present and match the selected chain
-    if (!$1564e43dde50bb61$var$blockscoutClient || $1564e43dde50bb61$var$blockscoutClient.chainId !== chainId) $1564e43dde50bb61$var$blockscoutClient = new ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786)({
-        chainId: chainId
-    });
+    // Get blockscout client for the given chain
+    let blockscoutClient = $1564e43dde50bb61$var$blockscoutClientMap.get(chainId);
+    if (!blockscoutClient) {
+        blockscoutClient = new ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786)({
+            chainId: chainId
+        });
+        $1564e43dde50bb61$var$blockscoutClientMap.set(chainId, blockscoutClient);
+    }
     // Hold the items in an array for post-fetching processing
     const items = [];
     const tokenType = ($887a00f8f72d61f0$export$5bd1ea2b3d18210).ERC20;
@@ -21972,7 +22045,7 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
     try {
         do {
             // eslint-disable-next-line no-await-in-loop
-            resp = await $1564e43dde50bb61$var$blockscoutClient.getTokensByWalletAddress({
+            resp = await blockscoutClient.getTokensByWalletAddress({
                 walletAddress: walletAddress,
                 tokenType: tokenType,
                 nextPage: resp?.next_page_params
@@ -21990,7 +22063,7 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
         if (err?.code !== (HttpStatusCode).NotFound) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(err.message || "InternalServerError | getTokensByWalletAddress", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_INDEXER_BALANCE_ERROR, err);
     }
     try {
-        const respNative = await $1564e43dde50bb61$var$blockscoutClient.getNativeTokenByWalletAddress({
+        const respNative = await blockscoutClient.getNativeTokenByWalletAddress({
             walletAddress: walletAddress
         });
         items.push(respNative);
@@ -22004,24 +22077,26 @@ const $1564e43dde50bb61$export$8c978679845804d4 = async (walletAddress, chainId,
         // or simply an incorrect wallet address was provided.
         if (err?.code !== (HttpStatusCode).NotFound) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(err.message || "InternalServerError | getNativeTokenByWalletAddress", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_INDEXER_BALANCE_ERROR, err);
     }
+    const balances = [];
+    items.forEach((item)=>{
+        if (shouldFilter && !mapFilterTokens[item.token.address]) return;
+        const tokenData = item.token || {};
+        const balance = (BigNumber$1).from(item.value);
+        let decimals = parseInt(tokenData.decimals, 10);
+        if (Number.isNaN(decimals)) decimals = ($d85ad1457a3f1a83$export$903389470ba9433c);
+        const token = {
+            ...tokenData,
+            decimals: decimals
+        };
+        const formattedBalance = (utils).formatUnits(item.value, token.decimals);
+        balances.push({
+            balance: balance,
+            formattedBalance: formattedBalance,
+            token: token
+        });
+    });
     return {
-        balances: items.map((item)=>{
-            const tokenData = item.token || {};
-            const balance = (BigNumber$1).from(item.value);
-            const renamed = mapRename[tokenData.address] || {};
-            const token = {
-                ...tokenData,
-                name: renamed.name ?? tokenData.name,
-                symbol: renamed.symbol ?? tokenData.symbol,
-                decimals: parseInt(tokenData.decimals, 10)
-            };
-            const formattedBalance = (utils).formatUnits(item.value, token.decimals);
-            return {
-                balance: balance,
-                formattedBalance: formattedBalance,
-                token: token
-            };
-        })
+        balances: balances
     };
 };
 const $1564e43dde50bb61$export$a3238cee431627c6 = async (config, web3Provider, walletAddress, tokens)=>{
@@ -22052,11 +22127,19 @@ const $1564e43dde50bb61$export$fee49741664a4d7e = async (config, web3Provider, w
         // eslint-disable-next-line no-console
         console.error(err);
     }
-    if (flag && ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786).isChainSupported(chainId)) return await $1564e43dde50bb61$export$8c978679845804d4(walletAddress, chainId, tokens);
+    if (flag && ($fd8a8472dcc3ec2b$export$ef140a6b05dfc786).isChainSupported(chainId)) {
+        // This is a hack because the widgets are still using the tokens symbol
+        // to drive the conversions. If we remove all the token symbols from e.g. zkevm
+        // then we would not have fiat conversions.
+        // Please remove this hack once https://immutable.atlassian.net/browse/WT-1710
+        // is done.
+        const isL1Chain = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config) === chainId;
+        return ($458d407830d66110$export$5280dbcb91c8b391)(config, `Time to fetch balances using blockscout for ${chainId}`, $1564e43dde50bb61$export$8c978679845804d4(walletAddress, chainId, isL1Chain ? tokens : []));
+    }
     // This fallback to use ERC20s calls which is a best effort solution
     // Fails in fetching data from the RCP calls might result in some
     // missing data.
-    return await $1564e43dde50bb61$export$a3238cee431627c6(config, web3Provider, walletAddress, tokens);
+    return await ($458d407830d66110$export$5280dbcb91c8b391)(config, `Time to fetch balances using RPC for ${chainId}`, $1564e43dde50bb61$export$a3238cee431627c6(config, web3Provider, walletAddress, tokens));
 };
 
 
@@ -22297,7 +22380,7 @@ async function $67fc622a2b913d5f$export$7cf6178417769841(chainId, config) {
         overrides: dexConfig?.overrides
     });
 }
-async function $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config) {
+function $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config) {
     return new (Orderbook)({
         baseConfig: {
             environment: config.environment
@@ -23098,8 +23181,8 @@ const $5e9bcae98dc8ff19$export$1165ca270f090a66 = (isDevelopment, isProduction)=
 
 
 
-const $1fda5c40669a566d$export$1fac8e857d728583 = async ()=>false;
-const $1fda5c40669a566d$export$2e83e9eeaf217e20 = async (config)=>{
+const $1fda5c40669a566d$export$5d79dcabf4595ae0 = async ()=>true;
+const $1fda5c40669a566d$export$2c2bcd6e0d9a9969 = async (config)=>{
     const availability = ($5e9bcae98dc8ff19$export$1165ca270f090a66)(config.isDevelopment, config.isProduction);
     try {
         return await availability.checkDexAvailability();
@@ -23120,18 +23203,18 @@ const $7f2e17f026d4fc8d$export$86d9f998ddda013e = async (config, provider)=>{
     const geoBlockingChecks = [];
     if (availableRoutingOptions.onRamp) geoBlockingChecks.push({
         id: "onRamp",
-        promise: ($1fda5c40669a566d$export$1fac8e857d728583)()
+        promise: ($1fda5c40669a566d$export$5d79dcabf4595ae0)()
     });
     if (availableRoutingOptions.swap) geoBlockingChecks.push({
         id: "swap",
-        promise: ($1fda5c40669a566d$export$2e83e9eeaf217e20)(config)
+        promise: ($1fda5c40669a566d$export$2c2bcd6e0d9a9969)(config)
     });
     if (geoBlockingChecks.length > 0) {
         const promises = geoBlockingChecks.map((geoBlockingCheck)=>geoBlockingCheck.promise);
         const geoBlockingStatus = await Promise.allSettled(promises);
         geoBlockingStatus.forEach((result, index)=>{
             const statusId = geoBlockingChecks[index].id;
-            availableRoutingOptions[statusId] = availableRoutingOptions[statusId] && result.status === "fulfilled" && !result.value;
+            availableRoutingOptions[statusId] = availableRoutingOptions[statusId] && result.status === "fulfilled" && result.value;
         });
     }
     // Bridge not available if passport provider
@@ -23238,7 +23321,7 @@ const $049bba630af05555$export$6946a1f17c2bbf26 = async (config, chainId, wallet
         }
         // Resolve all the quotes and link them back to the swappable token
         // The swappable token array is in the same position in the array as the quote in the promise array
-        const dexTransactionResponse = await Promise.allSettled(dexTransactionResponsePromises);
+        const dexTransactionResponse = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to resolve swap quotes from the dex", Promise.allSettled(dexTransactionResponsePromises));
         dexTransactionResponse.forEach((response, index)=>{
             if (response.status === "rejected") return; // Ignore any requests to dex that failed to resolve
             const swappableToken = fromToken[index];
@@ -23255,15 +23338,6 @@ const $049bba630af05555$export$6946a1f17c2bbf26 = async (config, chainId, wallet
 };
 
 
-const $3ee85f12225c19f3$export$fb80fe94a81a3132 = async (config, dexQuoteCache, walletAddress, requiredToken, swappableTokens)=>{
-    const dexQuotes = dexQuoteCache.get(requiredToken.address);
-    if (dexQuotes && dexQuotes.size > 0) return dexQuotes;
-    const quotes = await ($049bba630af05555$export$6946a1f17c2bbf26)(config, ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), walletAddress, requiredToken, swappableTokens);
-    dexQuoteCache.set(requiredToken.address, quotes);
-    return quotes;
-};
-
-
 const $91807edfd7057288$var$constructFees = (approvalGasFees, swapGasFees, swapFees)=>{
     let approvalGasFeeAmount = (BigNumber$1).from(0);
     let approvalGasFeeFormatted = "0";
@@ -23391,11 +23465,17 @@ const $91807edfd7057288$export$7b6318fc1a8067b3 = (l2Balances, approval)=>{
         approvalGasTokenAddress: approvalGasTokenAddress
     };
 };
-const $91807edfd7057288$export$38077235fe748d40 = (l2Balances, swapFees, approvalFees, tokenBeingSwapped)=>{
+const $91807edfd7057288$export$38077235fe748d40 = (l2Balances, approvalFees, swapGasFees, swapFees, tokenBeingSwapped)=>{
     // Set up a map of token addresses to amounts for each of the swap fees
     const feeMap = new Map();
     // Add the approval fee to list of fees
     if (approvalFees.approvalGasTokenAddress !== "") feeMap.set(approvalFees.approvalGasTokenAddress, approvalFees.approvalGasFee);
+    // Add the swap gas fee to list of fees
+    if (swapGasFees) {
+        const fee = feeMap.get(swapGasFees.token.address);
+        if (fee) feeMap.set(swapGasFees.token.address, fee.add(swapGasFees.value));
+        else feeMap.set(swapGasFees.token.address, swapGasFees.value);
+    }
     // Add the token being swapped to list of fees to ensure the user can cover the fee + the token swap
     if (tokenBeingSwapped) {
         const fee = feeMap.get(tokenBeingSwapped.address);
@@ -23444,7 +23524,7 @@ const $91807edfd7057288$export$567a0c83c08c514b = (l2balance, balanceRequirement
     // that is going to be swapped from another item requirement then return true
     return remainingBalance.gte(amountBeingSwapped);
 };
-const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutingOptions, dexQuoteCache, walletAddress, balanceRequirement, tokenBalanceResults, swappableTokens, balanceRequirements)=>{
+const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutingOptions, walletAddress, balanceRequirement, tokenBalanceResults, swappableTokens, balanceRequirements)=>{
     const fundingSteps = [];
     if (!availableRoutingOptions.swap) return fundingSteps;
     if (swappableTokens.length === 0) return fundingSteps;
@@ -23455,7 +23535,7 @@ const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutin
     if (!l2TokenBalanceResult) return fundingSteps;
     const l2Balances = l2TokenBalanceResult.balances;
     if (l2Balances.length === 0) return fundingSteps;
-    const quotes = await ($3ee85f12225c19f3$export$fb80fe94a81a3132)(config, dexQuoteCache, walletAddress, requiredToken, swappableTokens);
+    const quotes = await ($049bba630af05555$export$6946a1f17c2bbf26)(config, ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), walletAddress, requiredToken, swappableTokens);
     const quoteTokenAddresses = Array.from(quotes.keys());
     for (const quoteTokenAddress of quoteTokenAddresses){
         const quote = quotes.get(quoteTokenAddress);
@@ -23472,7 +23552,7 @@ const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutin
         // If user does not have enough to cover approval fees then continue
         if (!approvalFees.sufficient) continue;
         // If user does not have enough to cover swap fees then continue
-        if (!$91807edfd7057288$export$38077235fe748d40(l2Balances, quote.quote.fees, approvalFees, {
+        if (!$91807edfd7057288$export$38077235fe748d40(l2Balances, approvalFees, quote.swap, quote.quote.fees, {
             amount: amountOfQuoteTokenRequired.value,
             address: quoteTokenAddress
         })) continue;
@@ -23877,13 +23957,14 @@ const $7500587317643fc8$export$c3e193fd573f1a94 = async (config, swappableTokens
 
 
 
-const $d54df4a884f14123$export$d46f2133747ffd93 = async (config, dexQuoteCache, ownerAddress, requiredTokenAddress, insufficientRequirement, filteredSwappableTokens)=>{
+
+const $d54df4a884f14123$export$d46f2133747ffd93 = async (config, ownerAddress, requiredTokenAddress, insufficientRequirement, filteredSwappableTokens)=>{
     const filteredSwappableTokensAddresses = [];
     for (const token of filteredSwappableTokens){
         if (!token.address) continue;
         filteredSwappableTokensAddresses.push(token.address);
     }
-    const dexQuotes = await ($3ee85f12225c19f3$export$fb80fe94a81a3132)(config, dexQuoteCache, ownerAddress, {
+    const dexQuotes = await ($049bba630af05555$export$6946a1f17c2bbf26)(config, ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), ownerAddress, {
         address: requiredTokenAddress,
         amount: insufficientRequirement.delta.balance
     }, filteredSwappableTokensAddresses);
@@ -23993,7 +24074,7 @@ const $afd57acae9471ac5$export$d9b96654eebdaf2a = (bridgeFundingSteps, swapFundi
     }
     return bridgeAndSwapRoutes;
 };
-const $afd57acae9471ac5$export$f95ed27e871fe308 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, feeEstimates, tokenBalances, bridgeableTokens, swappableTokens, balanceRequirements)=>{
+const $afd57acae9471ac5$export$f95ed27e871fe308 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, feeEstimates, tokenBalances, bridgeableTokens, swappableTokens, balanceRequirements)=>{
     const { l1balances: l1balances, l2balances: l2balances } = ($7bb5af1d8b5d9127$export$8280985cc3da7882)(config, tokenBalances);
     const requiredTokenAddress = insufficientRequirement.required.token.address;
     if ($afd57acae9471ac5$export$b94e88f4f8805f71(bridgeableTokens, swappableTokens, l1balances, l2balances, availableRoutingOptions, requiredTokenAddress)) return [];
@@ -24004,7 +24085,7 @@ const $afd57acae9471ac5$export$f95ed27e871fe308 = async (config, readOnlyProvide
     const filteredSwappableTokens = $afd57acae9471ac5$export$ed7c59bd8d1bb5a7(requiredTokenAddress, bridgeableTokens, swappableTokens, l1tol2Addresses);
     if (filteredSwappableTokens.length === 0) return [];
     // Fetch all the dex quotes from the list of swappable tokens
-    const dexQuotes = await ($d54df4a884f14123$export$d46f2133747ffd93)(config, dexQuoteCache, ownerAddress, requiredTokenAddress, insufficientRequirement, filteredSwappableTokens);
+    const dexQuotes = await ($d54df4a884f14123$export$d46f2133747ffd93)(config, ownerAddress, requiredTokenAddress, insufficientRequirement, filteredSwappableTokens);
     // Construct bridge requirements based on L2 balances, slippage and swap fees
     const bridgeRequirements = ($62e968a3dd87940e$export$df667c749c93b110)(dexQuotes, l1balances, l2balances, l1tol2Addresses, balanceRequirements);
     if (bridgeRequirements.length === 0) return [];
@@ -24047,7 +24128,7 @@ const $afd57acae9471ac5$export$f95ed27e871fe308 = async (config, readOnlyProvide
     // Modify the users L2 balance to include the amount as if the user successfully bridged
     const modifiedTokenBalances = $afd57acae9471ac5$var$modifyTokenBalancesWithBridgedAmount(config, tokenBalances, l2balances, bridgedTokens, swappableTokens);
     // Call the swap route with the faked bridged balances
-    const swapRoutes = await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, modifiedTokenBalances, swappableTokensAfterBridging, balanceRequirements);
+    const swapRoutes = await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, ownerAddress, insufficientRequirement, modifiedTokenBalances, swappableTokensAfterBridging, balanceRequirements);
     if (!swapRoutes) return [];
     const originalBalanceSwapRoutes = $afd57acae9471ac5$export$1fc63300bde5e690(tokenBalances, swapRoutes);
     return $afd57acae9471ac5$export$d9b96654eebdaf2a(bridgeResults, originalBalanceSwapRoutes, l1tol2Addresses);
@@ -24089,6 +24170,7 @@ const $5649bc8af91da370$export$1fb2bd867f4a9be3 = async (config, availableRoutin
 
 
 
+
 const $c16168a9c28ae4fd$var$hasAvailableRoutingOptions = (availableRoutingOptions)=>availableRoutingOptions.bridge || availableRoutingOptions.swap || availableRoutingOptions.onRamp;
 const $c16168a9c28ae4fd$export$31ce7ba1a2956195 = (balanceRequirements)=>{
     let insufficientBalanceCount = 0;
@@ -24112,7 +24194,7 @@ const $c16168a9c28ae4fd$export$ab86023c267660 = async (config, readOnlyProviders
     if (availableRoutingOptions.bridge && insufficientRequirement) bridgeFundingStep = await ($fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa)(config, readOnlyProviders, ownerAddress, availableRoutingOptions, bridgeRequirement, tokenBalances, feeEstimates);
     return bridgeFundingStep;
 };
-const $c16168a9c28ae4fd$export$814624e957fa0f11 = async (config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, swapTokenAllowList, balanceRequirements)=>{
+const $c16168a9c28ae4fd$export$814624e957fa0f11 = async (config, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, swapTokenAllowList, balanceRequirements)=>{
     const fundingSteps = [];
     if (!availableRoutingOptions.swap) return fundingSteps;
     if (insufficientRequirement === undefined) return fundingSteps;
@@ -24123,9 +24205,9 @@ const $c16168a9c28ae4fd$export$814624e957fa0f11 = async (config, availableRoutin
     if (swapTokenAllowList.length === 0) return fundingSteps;
     const swappableTokens = swapTokenAllowList.filter((token)=>token.address).map((token)=>token.address);
     if (swappableTokens.length === 0) return fundingSteps;
-    return await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, tokenBalances, swappableTokens, balanceRequirements);
+    return await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, ownerAddress, insufficientRequirement, tokenBalances, swappableTokens, balanceRequirements);
 };
-const $c16168a9c28ae4fd$export$2becd43da9d21f73 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, tokenAllowList, feeEstimates, balanceRequirements)=>{
+const $c16168a9c28ae4fd$export$2becd43da9d21f73 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, tokenAllowList, feeEstimates, balanceRequirements)=>{
     if (!insufficientRequirement) return [];
     const l1balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
     const l2balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
@@ -24143,7 +24225,7 @@ const $c16168a9c28ae4fd$export$2becd43da9d21f73 = async (config, readOnlyProvide
     });
     const swapTokenAllowList = tokenAllowList?.swap ?? [];
     if (insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE && insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return [];
-    const routes = await ($afd57acae9471ac5$export$f95ed27e871fe308)(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, feeEstimates, tokenBalances, bridgeableL1Addresses, swapTokenAllowList, balanceRequirements);
+    const routes = await ($afd57acae9471ac5$export$f95ed27e871fe308)(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, feeEstimates, tokenBalances, bridgeableL1Addresses, swapTokenAllowList, balanceRequirements);
     return routes;
 };
 const $c16168a9c28ae4fd$export$e1b6e4d22d0365ee = async (config, availableRoutingOptions, insufficientRequirement)=>{
@@ -24165,20 +24247,18 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
             message: err.message
         });
     }
-    const tokenBalances = await ($33acec7b4a26c053$export$23ddeb2642d2f9d)(config, readOnlyProviders, ownerAddress, availableRoutingOptions);
-    const allowList = await ($5a5ccedc98d53d25$export$1ad29657d49c5440)(config, tokenBalances, availableRoutingOptions);
-    // Bridge and swap fee cache
+    const tokenBalances = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get token balances inside router", ($33acec7b4a26c053$export$23ddeb2642d2f9d)(config, readOnlyProviders, ownerAddress, availableRoutingOptions));
+    const allowList = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get routing allowlist", ($5a5ccedc98d53d25$export$1ad29657d49c5440)(config, tokenBalances, availableRoutingOptions));
+    // Fee estimate cache
     const feeEstimates = new Map();
-    // Dex quotes cache
-    const dexQuoteCache = new Map();
     // Ensures only 1 balance requirement is insufficient
     const insufficientRequirement = $c16168a9c28ae4fd$export$31ce7ba1a2956195(balanceRequirements);
     const routePromises = [];
     routePromises.push($c16168a9c28ae4fd$export$ab86023c267660(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, feeEstimates));
-    routePromises.push($c16168a9c28ae4fd$export$814624e957fa0f11(config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, allowList.swap, balanceRequirements));
+    routePromises.push($c16168a9c28ae4fd$export$814624e957fa0f11(config, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, allowList.swap, balanceRequirements));
     routePromises.push($c16168a9c28ae4fd$export$e1b6e4d22d0365ee(config, availableRoutingOptions, insufficientRequirement));
-    routePromises.push($c16168a9c28ae4fd$export$2becd43da9d21f73(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, allowList, feeEstimates, balanceRequirements));
-    const resolved = await Promise.all(routePromises);
+    routePromises.push($c16168a9c28ae4fd$export$2becd43da9d21f73(config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, allowList, feeEstimates, balanceRequirements));
+    const resolved = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to resolve all routes", Promise.all(routePromises));
     let bridgeFundingStep;
     let swapFundingSteps = [];
     let onRampFundingStep;
@@ -24245,26 +24325,31 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
 };
 
 
+
 const $0e7419077c373b24$export$9e073f9ada8c81e6 = async (config, provider, itemRequirements, transactionOrGasAmount)=>{
     const ownerAddress = await provider.getSigner().getAddress();
     let aggregatedItems = ($074f75878f618031$export$c804c9ade5c28607)(itemRequirements);
-    const erc20Allowances = await ($fc8b338399d890f3$export$d93c00812189e36)(provider, ownerAddress, aggregatedItems);
-    const erc721Allowances = await ($35c3fc7013888ba5$export$be546c525d418988)(provider, ownerAddress, aggregatedItems);
-    const aggregatedAllowances = ($ddc6bcd0896481e5$export$2fbfa41a4de56a89)(erc20Allowances, erc721Allowances);
-    const gasItem = await ($7d1bfafb81e64d74$export$3a4140bd9e983e4e)(provider, aggregatedAllowances, transactionOrGasAmount);
+    const erc20AllowancePromise = ($fc8b338399d890f3$export$d93c00812189e36)(provider, ownerAddress, aggregatedItems);
+    const erc721AllowancePromise = ($35c3fc7013888ba5$export$be546c525d418988)(provider, ownerAddress, aggregatedItems);
+    const resolvedAllowances = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to calculate token allowances", Promise.all([
+        erc20AllowancePromise,
+        erc721AllowancePromise
+    ]));
+    const aggregatedAllowances = ($ddc6bcd0896481e5$export$2fbfa41a4de56a89)(resolvedAllowances[0], resolvedAllowances[1]);
+    const gasItem = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to run gas calculator", ($7d1bfafb81e64d74$export$3a4140bd9e983e4e)(provider, aggregatedAllowances, transactionOrGasAmount));
     if (gasItem !== null) {
         aggregatedItems.push(gasItem);
         aggregatedItems = ($074f75878f618031$export$c804c9ade5c28607)(aggregatedItems);
     }
-    const balanceCheckResult = await ($beb896e098e41faf$export$ddfc885f43c3cb6e)(config, provider, ownerAddress, aggregatedItems);
+    const balanceCheckResult = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to run balance checks", ($beb896e098e41faf$export$ddfc885f43c3cb6e)(config, provider, ownerAddress, aggregatedItems));
     const { sufficient: sufficient } = balanceCheckResult;
     const transactionRequirements = balanceCheckResult.balanceRequirements;
     if (sufficient) return {
         sufficient: sufficient,
         transactionRequirements: transactionRequirements
     };
-    const availableRoutingOptions = await ($7f2e17f026d4fc8d$export$86d9f998ddda013e)(config, provider);
-    const routingOutcome = await ($c16168a9c28ae4fd$export$92606e71d0a264ff)(config, ownerAddress, balanceCheckResult, availableRoutingOptions);
+    const availableRoutingOptions = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to fetch available routing options", ($7f2e17f026d4fc8d$export$86d9f998ddda013e)(config, provider));
+    const routingOutcome = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Total time to run the routing calculator", ($c16168a9c28ae4fd$export$92606e71d0a264ff)(config, ownerAddress, balanceCheckResult, availableRoutingOptions));
     return {
         sufficient: sufficient,
         transactionRequirements: transactionRequirements,
@@ -24447,6 +24532,7 @@ const $9051cee080948594$export$1e69c9cfc42e28d8 = (orderFees, weiAmount, decimal
 };
 
 
+
 const $64863c39386de592$export$4249179755829904 = (type, contractAddress, amount, spenderAddress)=>{
     switch(type){
         case ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20:
@@ -24485,8 +24571,8 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     if (orders.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No orders were provided to the orders array. Please provide at least one order.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).FULFILL_ORDER_LISTING_ERROR);
     const { id: id, takerFees: takerFees } = orders[0];
     try {
-        orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
-        order = await orderbook.getListing(id);
+        orderbook = $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
+        order = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to fetch the listing from the orderbook", orderbook.getListing(id));
         const { seaportContractAddress: seaportContractAddress } = orderbook.config();
         spenderAddress = seaportContractAddress;
     } catch (err) {
@@ -24503,23 +24589,26 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     let decimals = 18;
     if (order.result.buy[0].type === "ERC20") {
         const tokenContract = $06a6c5c23f7f2479$export$fbbc17f6e6e58544(order.result.buy[0].contractAddress, ($d85ad1457a3f1a83$export$db5daa1b5156ccfe), provider);
-        decimals = await tokenContract.decimals();
+        decimals = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get decimals of token contract for the buy token", tokenContract.decimals());
     }
     let fees = [];
     if (takerFees && takerFees.length > 0) fees = ($9051cee080948594$export$1e69c9cfc42e28d8)(takerFees, buyToken.amount, decimals);
     let unsignedApprovalTransactions = [];
     let unsignedFulfillmentTransactions = [];
     let orderActions = [];
+    const fulfillOrderStartTime = new Date().getTime();
     try {
-        const fulfillerAddress = await provider.getSigner().getAddress();
-        const { actions: actions } = await orderbook.fulfillOrder(id, fulfillerAddress, fees);
+        const fulfillerAddress = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the address from the provider", provider.getSigner().getAddress());
+        const { actions: actions } = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to call fulfillOrder from the orderbook", orderbook.fulfillOrder(id, fulfillerAddress, fees));
         orderActions = actions;
-        unsignedApprovalTransactions = await (0, $a7367d01c6e76b1c$export$f64a20a30eb98855)(actions);
-    } catch  {
-    // Silently ignore error as this is usually thrown if user does not have enough balance
+        unsignedApprovalTransactions = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to construct the unsigned approval transactions", (0, $a7367d01c6e76b1c$export$f64a20a30eb98855)(actions));
+    } catch (err) {
+        // Silently ignore error as this is usually thrown if user does not have enough balance
+        const elapsedTimeInSeconds = (new Date().getTime() - fulfillOrderStartTime) / 1000;
+        ($458d407830d66110$export$e6a390ea6399b7d8)(config, "Time to call fulfillOrder from the orderbook", elapsedTimeInSeconds);
     }
     try {
-        unsignedFulfillmentTransactions = await (0, $a7367d01c6e76b1c$export$396bd6ce7d3ab533)(orderActions);
+        unsignedFulfillmentTransactions = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to construct the unsigned fulfillment transactions", (0, $a7367d01c6e76b1c$export$396bd6ce7d3ab533)(orderActions));
     } catch  {
     // if cannot estimate gas then silently continue and use gas limit in smartCheckout
     // but get the fulfillment transactions after they have approved the spending
@@ -24551,7 +24640,7 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
     const itemRequirements = [
         $64863c39386de592$export$4249179755829904(type, contractAddress, amount, spenderAddress)
     ];
-    const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedFulfillmentTransactions));
+    const smartCheckoutResult = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Total time running smart checkout", ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, $64863c39386de592$export$8f2ff92ab8657f0b(gasLimit, unsignedFulfillmentTransactions)));
     if (smartCheckoutResult.sufficient) {
         const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedApprovalTransactions);
         if (approvalResult.type === ($d855a5ba32004345$export$f51b97f3aaf2d5a8).FAILED) return {
@@ -24593,15 +24682,16 @@ const $64863c39386de592$export$7f8e2b98eca5a7f0 = async (config, provider, order
 
 
 
+
 const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, orderIds)=>{
     let unsignedCancelOrderTransaction;
     if (orderIds.length === 0) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No orderIds were provided to the orderIds array. Please provide at least one orderId.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CANCEL_ORDER_LISTING_ERROR);
     // Update this when bulk cancel is supported
     const orderId = orderIds[0];
     try {
-        const offererAddress = await provider.getSigner().getAddress();
-        const orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
-        const cancelOrderResponse = await orderbook.cancelOrder(orderId, offererAddress);
+        const offererAddress = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the address from the provider", provider.getSigner().getAddress());
+        const orderbook = $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
+        const cancelOrderResponse = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the cancel order from the orderbook", orderbook.cancelOrder(orderId, offererAddress));
         unsignedCancelOrderTransaction = cancelOrderResponse.unsignedCancelOrderTransaction;
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while cancelling the order listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CANCEL_ORDER_LISTING_ERROR, {
@@ -24634,6 +24724,7 @@ const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, order
 
 
 
+
 const $9085b221b72ac69e$export$af768ccdf17d5c04 = (id, contractAddress, spenderAddress)=>({
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
         id: id,
@@ -24662,15 +24753,15 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, order
     if (buyToken.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
         // get this from the allowed list
         const buyTokenContract = new (Contract$1)(buyToken.contractAddress, JSON.stringify(($d85ad1457a3f1a83$export$db5daa1b5156ccfe)), provider);
-        decimals = await buyTokenContract.decimals();
+        decimals = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get decimals of token contract for the buy token", buyTokenContract.decimals());
     }
     const buyTokenOrNative = $9085b221b72ac69e$export$586d02673c66d423(buyToken, decimals);
     try {
-        const walletAddress = await provider.getSigner().getAddress();
-        orderbook = await $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
+        const walletAddress = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the address from the provider", provider.getSigner().getAddress());
+        orderbook = $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
         const { seaportContractAddress: seaportContractAddress } = orderbook.config();
         spenderAddress = seaportContractAddress;
-        listing = await orderbook.prepareListing({
+        listing = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to prepare the listing from the orderbook", orderbook.prepareListing({
             makerAddress: walletAddress,
             buy: buyTokenOrNative,
             sell: {
@@ -24678,7 +24769,7 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, order
                 contractAddress: sellToken.collectionAddress,
                 tokenId: sellToken.id
             }
-        });
+        }));
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while preparing the listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PREPARE_ORDER_LISTING_ERROR, {
             message: err.message,
@@ -24689,13 +24780,13 @@ const $9085b221b72ac69e$export$e761f9e0703de895 = async (config, provider, order
     const itemRequirements = [
         $9085b221b72ac69e$export$af768ccdf17d5c04(sellToken.id, sellToken.collectionAddress, spenderAddress)
     ];
-    const smartCheckoutResult = await ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, {
+    const smartCheckoutResult = await ($458d407830d66110$export$5280dbcb91c8b391)(config, "Total time running smart checkout", ($0e7419077c373b24$export$9e073f9ada8c81e6)(config, provider, itemRequirements, {
         type: ($4b58188d47aafe8d$export$65c64e46348ee3c1).GAS,
         gasToken: {
             type: ($4b58188d47aafe8d$export$537fa3efd10ed435).NATIVE,
             limit: (BigNumber$1).from((constants).estimatedFulfillmentGasGwei)
         }
-    });
+    }));
     if (smartCheckoutResult.sufficient) {
         const unsignedTransactions = await ($a7367d01c6e76b1c$export$c5b3365853cb6159)(listing.actions);
         const approvalResult = await ($25ac589234c10b67$export$19693ca396db083e)(provider, unsignedTransactions.approvalTransactions);
@@ -25026,7 +25117,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
         const tokenList = await $efe60cea83bfc4e8$export$473cec51305fdae8(this.config, {
             type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ONRAMP
         });
-        const token = tokenList.tokens.find((t)=>t.address?.toLowerCase() === params.tokenAddress?.toLowerCase());
+        const token = tokenList.tokens?.find((t)=>t.address?.toLowerCase() === params.tokenAddress?.toLowerCase());
         if (token) {
             tokenAmount = params.tokenAmount;
             tokenSymbol = token.symbol;