@imtbl/sdk 0.22.0 → 0.22.1

package/dist/index.js

@@ -22,7 +22,6 @@ import assert from 'assert';
 import { FeeAmount, Route, SwapQuoter, Pool, Trade, toHex as toHex$1, encodeRouteToPath } from '@uniswap/v3-sdk';
 import { keccak256 as keccak256$1 } from '@ethersproject/solidity';
 import { SwapRouter } from '@uniswap/router-sdk';
-import { parseUnits as parseUnits$1 } from 'ethers/lib/utils';
 import { jsx } from 'react/jsx-runtime';
 import { useEffect } from 'react';
 
@@ -2988,7 +2987,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.22.0' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.22.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3048,7 +3047,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.22.0',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.22.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -3334,7 +3333,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.22.0',
+    sdkVersion: 'ts-immutable-sdk-0.22.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -11303,11 +11302,14 @@ class Orderbook {
                 })),
             },
         ]);
-        if (fulfillmentDataRes.result.length !== 1) {
-            throw new Error('unexpected fulfillment data result length');
+        if (fulfillmentDataRes.result.unfulfillable_orders?.length > 0) {
+            throw new Error(`Unable to prepare fulfillment date: ${fulfillmentDataRes.result.unfulfillable_orders[0].reason}`);
         }
-        const extraData = fulfillmentDataRes.result[0].extra_data;
-        const orderResult = fulfillmentDataRes.result[0].order;
+        else if (fulfillmentDataRes.result.fulfillable_orders?.length !== 1) {
+            throw new Error('unexpected fulfillable order result length');
+        }
+        const extraData = fulfillmentDataRes.result.fulfillable_orders[0].extra_data;
+        const orderResult = fulfillmentDataRes.result.fulfillable_orders[0].order;
         if (orderResult.status !== OrderStatus.ACTIVE) {
             throw new Error(`Cannot fulfil order that is not active. Current status: ${orderResult.status}`);
         }
@@ -30159,6 +30161,7 @@ const $7f2e17f026d4fc8d$export$f1ca3744c025ab81 = async (config, provider)=>{
 
 
 
+
 var $b23305044c0e096a$export$3057de18ac0c076;
 (function(RouteCalculatorType) {
     RouteCalculatorType["ROUTES_FOUND"] = "ROUTES_FOUND";
@@ -30220,214 +30223,6 @@ const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, readOnlyProvider
 };
 
 
-/* eslint-disable @typescript-eslint/no-unused-vars */ 
-
-
-
-const $f730af3b727f04ac$export$22fea095b15361de = (balances)=>{
-    for (const balance of balances.balances){
-        if (!balance.token.address || balance.token.address === "") return balance.balance;
-    }
-    return (BigNumber$1).from(0);
-};
-
-
-
-
-
-
-const $8a49d1a3783a2640$export$3aff971444a4f244 = async (config, readOnlyProviders)=>{
-    try {
-        const estimate = await (0, $2e7bf45a7c9a9570$export$942c8de7174809fc)({
-            gasEstimateType: (0, $de275b98d2b651c3$export$788b1fd17f3dad84).BRIDGE_TO_L2,
-            isSpendingCapApprovalRequired: false
-        }, readOnlyProviders, config);
-        const gasEstimate = estimate.gasFee.estimatedAmount;
-        const bridgeFee = estimate.bridgeFee.estimatedAmount;
-        let totalFees = (0, BigNumber$1).from(0);
-        if (gasEstimate) totalFees = totalFees.add(gasEstimate);
-        if (bridgeFee) totalFees = totalFees.add(bridgeFee);
-        return totalFees;
-    } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error estimating gas for bridge", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
-            message: err.message
-        });
-    }
-};
-
-
-
-const $823db9fb0ca4bc15$export$c37d8687c27b9660 = "0x0000000000000000000000000000000000000001";
-const $823db9fb0ca4bc15$export$1430626eec86fce9 = (chainId)=>{
-    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET) return "imtbl-zkevm-testnet";
-    return "";
-};
-const $823db9fb0ca4bc15$export$53e663abd9b77fc1 = async (chainId, config)=>{
-    const imxMappingConfig = await config.remote.getConfig("imxAddressMapping");
-    return imxMappingConfig[chainId] ?? "";
-};
-
-
-
-
-
-
-
-const $07ac9c0576988336$export$7847f5f5cce25dfa = async (config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, token, depositAmount)=>{
-    try {
-        const tokenBridge = await $67fc622a2b913d5f$export$989eefe1274a439c(fromChainId, toChainId, readOnlyProviders, config);
-        const { unsignedTx: unsignedTx } = await tokenBridge.getUnsignedApproveDepositBridgeTx({
-            depositorAddress: depositorAddress,
-            token: token,
-            depositAmount: depositAmount
-        });
-        if (unsignedTx === null) return (0, BigNumber$1).from(0);
-        return await l1provider.estimateGas(unsignedTx);
-    } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error occurred while attempting ot estimate gas for approval transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
-            message: err.message
-        });
-    }
-};
-const $07ac9c0576988336$export$a3dd181de896b7c7 = async (config, readOnlyProviders, l1provider, depositorAddress, l1Address, delta)=>{
-    if (l1Address === ($823db9fb0ca4bc15$export$c37d8687c27b9660)) return (BigNumber$1).from(0); // Native ETH does not require approval
-    const fromChainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
-    const toChainId = ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config);
-    return await $07ac9c0576988336$export$7847f5f5cce25dfa(config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, l1Address, delta);
-};
-
-
-
-
-const $5a5ccedc98d53d25$var$filterTokens = (allowedTokens, balances)=>{
-    if (balances && balances.success) return allowedTokens.filter((token)=>{
-        if ("address" in token) return balances.balances.find((balance)=>balance.token.address === token.address && balance.balance.gt(0));
-        return balances.balances.find((balance)=>!("address" in balance.token) && balance.balance.gt(0));
-    });
-    return [];
-};
-const $5a5ccedc98d53d25$export$9ec9fc71f3ce62c4 = async (config, availableRoutingOptions)=>{
-    if (availableRoutingOptions.onRamp) {
-        const onRampOptions = await config.remote.getConfig("onramp");
-        const onRampAllowList = {};
-        Object.entries(onRampOptions).forEach(([onRampProvider, onRampProviderConfig])=>{
-            // Allowed list per onRamp provider
-            onRampAllowList[onRampProvider] = onRampProviderConfig.tokens ?? [];
-        });
-        return onRampAllowList;
-    }
-    return {};
-};
-const $5a5ccedc98d53d25$export$d744af9f1c0712bc = async (config, tokenBalances, availableRoutingOptions)=>{
-    if (availableRoutingOptions.bridge) {
-        const allowedTokens = (await config.remote.getConfig("bridge"))?.tokens ?? [];
-        const balances = tokenBalances.get(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
-        return $5a5ccedc98d53d25$var$filterTokens(allowedTokens, balances);
-    }
-    return [];
-};
-const $5a5ccedc98d53d25$export$87ed7f956d73690 = async (config, tokenBalances, availableRoutingOptions)=>{
-    if (availableRoutingOptions.swap) {
-        const allowedTokens = (await config.remote.getConfig("dex"))?.tokens ?? [];
-        const balances = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
-        return $5a5ccedc98d53d25$var$filterTokens(allowedTokens, balances);
-    }
-    return [];
-};
-const $5a5ccedc98d53d25$export$1ad29657d49c5440 = async (config, tokenBalances, availableRoutingOptions)=>{
-    const tokenAllowList = {};
-    tokenAllowList.swap = await $5a5ccedc98d53d25$export$87ed7f956d73690(config, tokenBalances, availableRoutingOptions);
-    tokenAllowList.bridge = await $5a5ccedc98d53d25$export$d744af9f1c0712bc(config, tokenBalances, availableRoutingOptions);
-    tokenAllowList.onRamp = await $5a5ccedc98d53d25$export$9ec9fc71f3ce62c4(config, availableRoutingOptions);
-    return tokenAllowList;
-};
-
-
-const $fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665 = (balances, totalFees)=>{
-    const balance = ($f730af3b727f04ac$export$22fea095b15361de)(balances);
-    return balance.gte(totalFees);
-};
-const $fa9ac5bfdbbf9dfa$export$97330fab5f794e7f = (balanceRequirement)=>{
-    if (balanceRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return $d85ad1457a3f1a83$export$b80040cb173ba6e9;
-    if (balanceRequirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return balanceRequirement.required.token.address ?? "";
-    return "";
-};
-const $fa9ac5bfdbbf9dfa$export$952cdf461a00a8c6 = async (config, balanceRequirement)=>{
-    const l2address = $fa9ac5bfdbbf9dfa$export$97330fab5f794e7f(balanceRequirement);
-    if (l2address === "") return "";
-    if (l2address === ($d85ad1457a3f1a83$export$b80040cb173ba6e9)) return await ($823db9fb0ca4bc15$export$53e663abd9b77fc1)(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config), config);
-    const chainName = ($823db9fb0ca4bc15$export$1430626eec86fce9)(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
-    if (chainName === "") return ""; // Chain name not a valid indexer chain name
-    const blockchainData = ($67fc622a2b913d5f$export$436dd76f23f463ff)(config);
-    const tokenData = await blockchainData.getToken({
-        chainName: chainName,
-        contractAddress: l2address
-    });
-    const l1address = tokenData.result.root_contract_address;
-    if (l1address === null) return ""; // No L1 representation of this token
-    return l1address;
-};
-const $fa9ac5bfdbbf9dfa$export$da05aed50d75046 = async (config, readOnlyProviders, feeEstimates)=>{
-    let bridgeFeeEstimate = feeEstimates.get(($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE);
-    if (bridgeFeeEstimate) return bridgeFeeEstimate;
-    bridgeFeeEstimate = await ($8a49d1a3783a2640$export$3aff971444a4f244)(config, readOnlyProviders);
-    feeEstimates.set(($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE, bridgeFeeEstimate);
-    return bridgeFeeEstimate;
-};
-const $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute = (chainId, balance)=>({
-        type: ($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE,
-        chainId: chainId,
-        asset: {
-            balance: balance.balance,
-            formattedBalance: balance.formattedBalance,
-            token: {
-                name: balance.token.name,
-                symbol: balance.token.symbol,
-                address: balance.token.address,
-                decimals: balance.token.decimals
-            }
-        }
-    });
-const $fa9ac5bfdbbf9dfa$export$3139474685e4dedd = (address)=>{
-    if (!address || address === "") return true;
-    return false;
-};
-const $fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa = async (config, readOnlyProviders, depositorAddress, availableRoutingOptions, balanceRequirement, balances, feeEstimates)=>{
-    if (!availableRoutingOptions.bridge) return undefined;
-    const chainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
-    const tokenBalanceResult = balances.get(chainId);
-    const l1provider = readOnlyProviders.get(chainId);
-    if (!l1provider) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No L1 provider available", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR, {
-        chainId: chainId.toString()
-    });
-    // If no balances on layer 1 then Bridge cannot be an option
-    if (tokenBalanceResult === undefined || tokenBalanceResult.success === false) return undefined;
-    const allowedTokenList = await ($5a5ccedc98d53d25$export$d744af9f1c0712bc)(config, balances, availableRoutingOptions);
-    if (allowedTokenList.length === 0) return undefined;
-    const bridgeFeeEstimate = await $fa9ac5bfdbbf9dfa$export$da05aed50d75046(config, readOnlyProviders, feeEstimates);
-    // If the user has no ETH to cover the bridge fees or approval fees then bridge cannot be an option
-    if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, bridgeFeeEstimate)) return undefined;
-    const l1address = await $fa9ac5bfdbbf9dfa$export$952cdf461a00a8c6(config, balanceRequirement);
-    if (l1address === "") return undefined;
-    // Ensure l1address is in the allowed token list
-    if (l1address === ($823db9fb0ca4bc15$export$c37d8687c27b9660)) {
-        if (!allowedTokenList.find((token)=>!("address" in token))) return undefined;
-    } else if (!allowedTokenList.find((token)=>token.address === l1address)) return undefined;
-    const gasForApproval = await ($07ac9c0576988336$export$a3dd181de896b7c7)(config, readOnlyProviders, l1provider, depositorAddress, l1address, balanceRequirement.delta.balance);
-    if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, gasForApproval.add(bridgeFeeEstimate))) return undefined;
-    // If the L1 representation of the requirement is ETH then find the ETH balance and check if the balance covers the delta
-    if (l1address === ($823db9fb0ca4bc15$export$c37d8687c27b9660)) {
-        const nativeETHBalance = tokenBalanceResult.balances.find((balance)=>$fa9ac5bfdbbf9dfa$export$3139474685e4dedd(balance.token.address));
-        if (nativeETHBalance && nativeETHBalance.balance.gte(balanceRequirement.delta.balance.add(bridgeFeeEstimate))) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, nativeETHBalance);
-        return undefined;
-    }
-    // Find the balance of the L1 representation of the token and check if the balance covers the delta
-    const erc20balance = tokenBalanceResult.balances.find((balance)=>balance.token.address === l1address);
-    if (erc20balance && erc20balance.balance.gte(balanceRequirement.delta.balance)) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, erc20balance);
-    return undefined;
-};
-
-
 
 
 
@@ -30456,11 +30251,13 @@ async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnl
 
 const $049bba630af05555$export$6946a1f17c2bbf26 = async (config, chainId, walletAddress, requiredToken, swappableTokens)=>{
     const dexQuotes = new Map();
+    // Apply a small slippage percent as a buffer to cover price fluctuations between token pairs
+    const slippagePercent = 1;
     try {
         const exchange = await $67fc622a2b913d5f$export$7cf6178417769841(chainId, config);
         const dexTransactionResponsePromises = [];
         // Create a quote for each swappable token
-        for (const swappableToken of swappableTokens)dexTransactionResponsePromises.push(exchange.getUnsignedSwapTxFromAmountOut(walletAddress, swappableToken, requiredToken.address, requiredToken.amount));
+        for (const swappableToken of swappableTokens)dexTransactionResponsePromises.push(exchange.getUnsignedSwapTxFromAmountOut(walletAddress, swappableToken, requiredToken.address, requiredToken.amount, slippagePercent));
         // 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.all(dexTransactionResponsePromises);
@@ -30481,7 +30278,7 @@ 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) return dexQuotes;
+    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;
@@ -30618,6 +30415,506 @@ const $91807edfd7057288$export$8e03ea04d59f2402 = async (config, availableRoutin
 
 
 
+const $5a5ccedc98d53d25$var$filterTokens = (allowedTokens, balances)=>{
+    if (balances && balances.success) return allowedTokens.filter((token)=>{
+        if ("address" in token) return balances.balances.find((balance)=>balance.token.address === token.address && balance.balance.gt(0));
+        return balances.balances.find((balance)=>!("address" in balance.token) && balance.balance.gt(0));
+    });
+    return [];
+};
+const $5a5ccedc98d53d25$export$9ec9fc71f3ce62c4 = async (config, availableRoutingOptions)=>{
+    if (availableRoutingOptions.onRamp) {
+        const onRampOptions = await config.remote.getConfig("onramp");
+        const onRampAllowList = {};
+        Object.entries(onRampOptions).forEach(([onRampProvider, onRampProviderConfig])=>{
+            // Allowed list per onRamp provider
+            onRampAllowList[onRampProvider] = onRampProviderConfig.tokens ?? [];
+        });
+        return onRampAllowList;
+    }
+    return {};
+};
+const $5a5ccedc98d53d25$export$d744af9f1c0712bc = async (config, tokenBalances, availableRoutingOptions)=>{
+    if (availableRoutingOptions.bridge) {
+        const allowedTokens = (await config.remote.getConfig("bridge"))?.tokens ?? [];
+        const balances = tokenBalances.get(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
+        return $5a5ccedc98d53d25$var$filterTokens(allowedTokens, balances);
+    }
+    return [];
+};
+const $5a5ccedc98d53d25$export$87ed7f956d73690 = async (config, tokenBalances, availableRoutingOptions)=>{
+    if (availableRoutingOptions.swap) {
+        const allowedTokens = (await config.remote.getConfig("dex"))?.tokens ?? [];
+        const balances = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+        return $5a5ccedc98d53d25$var$filterTokens(allowedTokens, balances);
+    }
+    return [];
+};
+const $5a5ccedc98d53d25$export$1ad29657d49c5440 = async (config, tokenBalances, availableRoutingOptions)=>{
+    const tokenAllowList = {};
+    tokenAllowList.swap = await $5a5ccedc98d53d25$export$87ed7f956d73690(config, tokenBalances, availableRoutingOptions);
+    tokenAllowList.bridge = await $5a5ccedc98d53d25$export$d744af9f1c0712bc(config, tokenBalances, availableRoutingOptions);
+    tokenAllowList.onRamp = await $5a5ccedc98d53d25$export$9ec9fc71f3ce62c4(config, availableRoutingOptions);
+    return tokenAllowList;
+};
+
+
+
+
+
+
+
+
+
+const $f730af3b727f04ac$export$22fea095b15361de = (balances)=>{
+    for (const balance of balances.balances){
+        if (!balance.token.address || balance.token.address === "") return balance.balance;
+    }
+    return (BigNumber$1).from(0);
+};
+
+
+
+
+
+
+const $8a49d1a3783a2640$export$3aff971444a4f244 = async (config, readOnlyProviders)=>{
+    try {
+        const estimate = await (0, $2e7bf45a7c9a9570$export$942c8de7174809fc)({
+            gasEstimateType: (0, $de275b98d2b651c3$export$788b1fd17f3dad84).BRIDGE_TO_L2,
+            isSpendingCapApprovalRequired: false
+        }, readOnlyProviders, config);
+        const gasEstimate = estimate.gasFee.estimatedAmount;
+        const bridgeFee = estimate.bridgeFee.estimatedAmount;
+        let totalFees = (0, BigNumber$1).from(0);
+        if (gasEstimate) totalFees = totalFees.add(gasEstimate);
+        if (bridgeFee) totalFees = totalFees.add(bridgeFee);
+        return totalFees;
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error estimating gas for bridge", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
+            message: err.message
+        });
+    }
+};
+
+
+
+
+
+
+
+
+
+const $887d24b47765b1c0$export$c37d8687c27b9660 = "0x0000000000000000000000000000000000000001";
+const $887d24b47765b1c0$export$1430626eec86fce9 = (chainId)=>{
+    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).IMTBL_ZKEVM_TESTNET) return "imtbl-zkevm-testnet";
+    return "";
+};
+const $887d24b47765b1c0$export$53e663abd9b77fc1 = async (chainId, config)=>{
+    const imxMappingConfig = await config.remote.getConfig("imxAddressMapping");
+    return imxMappingConfig[chainId] ?? "";
+};
+const $887d24b47765b1c0$export$952cdf461a00a8c6 = async (config, l2address)=>{
+    if (l2address === "") return {
+        l1address: "",
+        l2address: l2address
+    };
+    if (l2address === ($d85ad1457a3f1a83$export$b80040cb173ba6e9)) return {
+        l1address: await $887d24b47765b1c0$export$53e663abd9b77fc1(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config), config),
+        l2address: ($d85ad1457a3f1a83$export$b80040cb173ba6e9)
+    };
+    const chainName = $887d24b47765b1c0$export$1430626eec86fce9(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+    if (chainName === "") return {
+        l1address: "",
+        l2address: l2address
+    }; // Chain name not a valid indexer chain name
+    const blockchainData = ($67fc622a2b913d5f$export$436dd76f23f463ff)(config);
+    const tokenData = await blockchainData.getToken({
+        chainName: chainName,
+        contractAddress: l2address
+    });
+    const l1address = tokenData.result.root_contract_address;
+    if (l1address === null) return {
+        l1address: "",
+        l2address: l2address
+    }; // No L1 representation of this token
+    return {
+        l1address: l1address,
+        l2address: l2address
+    };
+};
+
+
+const $07ac9c0576988336$export$7847f5f5cce25dfa = async (config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, token, depositAmount)=>{
+    try {
+        const tokenBridge = await $67fc622a2b913d5f$export$989eefe1274a439c(fromChainId, toChainId, readOnlyProviders, config);
+        const { unsignedTx: unsignedTx } = await tokenBridge.getUnsignedApproveDepositBridgeTx({
+            depositorAddress: depositorAddress,
+            token: token,
+            depositAmount: depositAmount
+        });
+        if (unsignedTx === null) return (0, BigNumber$1).from(0);
+        return await l1provider.estimateGas(unsignedTx);
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error occurred while attempting ot estimate gas for approval transaction", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).BRIDGE_GAS_ESTIMATE_ERROR, {
+            message: err.message
+        });
+    }
+};
+const $07ac9c0576988336$export$a3dd181de896b7c7 = async (config, readOnlyProviders, l1provider, depositorAddress, l1Address, delta)=>{
+    if (l1Address === ($887d24b47765b1c0$export$c37d8687c27b9660)) return (BigNumber$1).from(0); // Native ETH does not require approval
+    const fromChainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
+    const toChainId = ($4013c5c91bb535f6$export$c9af4e4b001c6476)(config);
+    return await $07ac9c0576988336$export$7847f5f5cce25dfa(config, readOnlyProviders, l1provider, depositorAddress, fromChainId, toChainId, l1Address, delta);
+};
+
+
+
+
+
+const $fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665 = (tokenBalanceResult, totalFees)=>{
+    const balance = ($f730af3b727f04ac$export$22fea095b15361de)(tokenBalanceResult);
+    return balance.gte(totalFees);
+};
+const $fa9ac5bfdbbf9dfa$export$da05aed50d75046 = async (config, readOnlyProviders, feeEstimates)=>{
+    let bridgeFeeEstimate = feeEstimates.get(($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE);
+    if (bridgeFeeEstimate) return bridgeFeeEstimate;
+    bridgeFeeEstimate = await ($8a49d1a3783a2640$export$3aff971444a4f244)(config, readOnlyProviders);
+    feeEstimates.set(($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE, bridgeFeeEstimate);
+    return bridgeFeeEstimate;
+};
+const $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute = (chainId, balance)=>({
+        type: ($4b58188d47aafe8d$export$3af78bb3e8650ee6).BRIDGE,
+        chainId: chainId,
+        asset: {
+            balance: balance.balance,
+            formattedBalance: balance.formattedBalance,
+            token: {
+                name: balance.token.name,
+                symbol: balance.token.symbol,
+                address: balance.token.address,
+                decimals: balance.token.decimals
+            }
+        }
+    });
+const $fa9ac5bfdbbf9dfa$export$3139474685e4dedd = (address)=>{
+    if (!address || address === "") return true;
+    return false;
+};
+const $fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa = async (config, readOnlyProviders, depositorAddress, availableRoutingOptions, bridgeRequirement, tokenBalanceResults, feeEstimates)=>{
+    if (!availableRoutingOptions.bridge) return undefined;
+    if (bridgeRequirement.l2address === undefined || bridgeRequirement.l2address === "") return undefined;
+    const chainId = ($4013c5c91bb535f6$export$9b794d067cdd1af6)(config);
+    const tokenBalanceResult = tokenBalanceResults.get(chainId);
+    const l1provider = readOnlyProviders.get(chainId);
+    if (!l1provider) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No L1 provider available", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR, {
+        chainId: chainId.toString()
+    });
+    // If no balances on layer 1 then Bridge cannot be an option
+    if (tokenBalanceResult === undefined || tokenBalanceResult.success === false) return undefined;
+    const allowedTokenList = await ($5a5ccedc98d53d25$export$d744af9f1c0712bc)(config, tokenBalanceResults, availableRoutingOptions);
+    if (allowedTokenList.length === 0) return undefined;
+    const bridgeFeeEstimate = await $fa9ac5bfdbbf9dfa$export$da05aed50d75046(config, readOnlyProviders, feeEstimates);
+    // If the user has no ETH to cover the bridge fees or approval fees then bridge cannot be an option
+    if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, bridgeFeeEstimate)) return undefined;
+    const l1RepresentationResult = await ($887d24b47765b1c0$export$952cdf461a00a8c6)(config, bridgeRequirement.l2address);
+    // No mapping on L1 for this token
+    const { l1address: l1address } = l1RepresentationResult;
+    if (l1address === "") return undefined;
+    // Ensure l1address is in the allowed token list
+    if (l1address === ($887d24b47765b1c0$export$c37d8687c27b9660)) {
+        if (!allowedTokenList.find((token)=>!("address" in token))) return undefined;
+    } else if (!allowedTokenList.find((token)=>token.address === l1address)) return undefined;
+    const gasForApproval = await ($07ac9c0576988336$export$a3dd181de896b7c7)(config, readOnlyProviders, l1provider, depositorAddress, l1address, bridgeRequirement.amount);
+    if (!$fa9ac5bfdbbf9dfa$export$9994ad18c2f0e665(tokenBalanceResult, gasForApproval.add(bridgeFeeEstimate))) return undefined;
+    // If the L1 representation of the requirement is ETH then find the ETH balance and check if the balance covers the delta
+    if (l1address === ($887d24b47765b1c0$export$c37d8687c27b9660)) {
+        const nativeETHBalance = tokenBalanceResult.balances.find((balance)=>$fa9ac5bfdbbf9dfa$export$3139474685e4dedd(balance.token.address));
+        if (nativeETHBalance && nativeETHBalance.balance.gte(bridgeRequirement.amount.add(bridgeFeeEstimate))) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, nativeETHBalance);
+        return undefined;
+    }
+    // Find the balance of the L1 representation of the token and check if the balance covers the delta
+    const erc20balance = tokenBalanceResult.balances.find((balance)=>balance.token.address === l1address);
+    if (erc20balance && erc20balance.balance.gte(bridgeRequirement.amount)) return $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute(chainId, erc20balance);
+    return undefined;
+};
+
+
+
+
+const $7bb5af1d8b5d9127$export$8280985cc3da7882 = (config, tokenBalances)=>{
+    const balances = {
+        l1balances: [],
+        l2balances: []
+    };
+    const l1balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
+    const l2balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+    // If there are no l1 balance then cannot bridge
+    if (!l1balancesResult) return balances;
+    if (l1balancesResult.error !== undefined) return balances;
+    if (!l1balancesResult.success) return balances;
+    // If there are no l2 balance then cannot swap
+    if (!l2balancesResult) return balances;
+    if (l2balancesResult.error !== undefined) return balances;
+    if (!l2balancesResult.success) return balances;
+    const l1balances = l1balancesResult.balances;
+    const l2balances = l2balancesResult.balances;
+    return {
+        l1balances: l1balances,
+        l2balances: l2balances
+    };
+};
+
+
+
+
+
+const $62e968a3dd87940e$export$8059963805b7876c = (dexQuote, tokenAddress)=>{
+    let fees = (BigNumber$1).from(0);
+    dexQuote.quote.fees.forEach((fee)=>{
+        if (fee.amount.token.address === tokenAddress) fees = fees.add(fee.amount.value);
+    });
+    if (dexQuote.approval) {
+        if (dexQuote.approval.token.address === tokenAddress) fees = fees.add(dexQuote.approval.value);
+    }
+    return fees;
+};
+// The token that is being bridged may also be a balance requirement
+// Since this token is going to be swapped after bridging then get the
+// balance requirement amount so this can be considered when bridging
+// enough of the token across
+const $62e968a3dd87940e$var$getAmountFromBalanceRequirement = (balanceRequirements, tokenAddress)=>{
+    let amount = (BigNumber$1).from(0);
+    balanceRequirements.balanceRequirements.forEach((requirement)=>{
+        if (requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE || requirement.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) {
+            if (requirement.required.token.address === tokenAddress) amount = amount.add(requirement.required.balance);
+        }
+    });
+    return amount;
+};
+const $62e968a3dd87940e$export$df667c749c93b110 = (dexQuotes, l1balances, l2balances, l1tol2addresses, balanceRequirements)=>{
+    const bridgeRequirements = [];
+    for (const [tokenAddress, quote] of dexQuotes){
+        // Get the L2 balance for the token address
+        const l2balance = l2balances.find((balance)=>balance.token.address === tokenAddress);
+        const l1tol2TokenMapping = l1tol2addresses.find((token)=>token.l2address === tokenAddress);
+        if (!l1tol2TokenMapping) continue;
+        const { l1address: l1address, l2address: l2address } = l1tol2TokenMapping;
+        if (!l1address) continue;
+        // If the user does not have any L1 balance for this token then cannot bridge
+        const l1balance = l1balances.find((balance)=>{
+            if (balance.token.address === undefined && l1address === ($887d24b47765b1c0$export$c37d8687c27b9660)) return true;
+            return balance.token.address === l1address;
+        });
+        if (!l1balance) continue;
+        // Get the total amount using slippage to ensure a small buffer is added to cover price fluctuations
+        const quotedAmount = quote.quote.amountWithMaxSlippage.value;
+        // Add fees to the quoted amount if the fees are in the same token as the token being swapped
+        const fees = $62e968a3dd87940e$export$8059963805b7876c(quote, tokenAddress);
+        // If the token being bridged is a balance requirement then add this to the total
+        // to ensure when its swapped the balance requirement can still be fulfilled
+        const balanceRequirementAmount = $62e968a3dd87940e$var$getAmountFromBalanceRequirement(balanceRequirements, tokenAddress);
+        // Add all the amounts together
+        const totalAmount = quotedAmount.add(fees).add(balanceRequirementAmount);
+        // Subtract any L2 balance from the total amount to only bridge the necessary amount
+        const amountToBridge = l2balance ? totalAmount.sub(l2balance.balance) : totalAmount;
+        if (amountToBridge.lte(0)) continue;
+        if (amountToBridge.gt(l1balance.balance)) continue;
+        bridgeRequirements.push({
+            amount: amountToBridge,
+            formattedAmount: (utils$1).formatUnits(amountToBridge, l1balance.token.decimals),
+            l2address: // L2 address is used for the bridge requirement as the bridge route uses the indexer to find L1 address
+            l2address
+        });
+    }
+    return bridgeRequirements;
+};
+
+
+
+const $7500587317643fc8$export$c3e193fd573f1a94 = async (config, swappableTokens)=>{
+    const l1tol2addressMappingPromises = swappableTokens.map((token)=>($887d24b47765b1c0$export$952cdf461a00a8c6)(config, token.address ?? ""));
+    return await Promise.all(l1tol2addressMappingPromises);
+};
+
+
+
+
+const $d54df4a884f14123$export$d46f2133747ffd93 = async (config, dexQuoteCache, 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, {
+        address: requiredTokenAddress,
+        amount: insufficientRequirement.delta.balance
+    }, filteredSwappableTokensAddresses);
+    return dexQuotes;
+};
+
+
+const $afd57acae9471ac5$export$b94e88f4f8805f71 = (bridgeableTokens, swappableTokens, l1balances, l2balances, availableRoutingOptions, requiredTokenAddress)=>{
+    if (bridgeableTokens.length === 0) return true;
+    if (swappableTokens.length === 0) return true;
+    if (l1balances.length === 0) return true;
+    if (l2balances.length === 0) return true;
+    if (!availableRoutingOptions.bridge) return true;
+    if (!availableRoutingOptions.swap) return true;
+    if (requiredTokenAddress === undefined) return true;
+    if (requiredTokenAddress === "") return true;
+    return false;
+};
+const $afd57acae9471ac5$export$ed7c59bd8d1bb5a7 = (requiredTokenAddress, bridgeableTokens, swappableTokens, l1tol2Addresses)=>{
+    const filteredSwappableTokens = [];
+    for (const addresses of l1tol2Addresses){
+        if (addresses.l1address === "") continue;
+        if (addresses.l2address === "") continue;
+        if (!bridgeableTokens.includes(addresses.l1address)) continue;
+        // Filter out the token that is required from the swappable tokens list
+        if (addresses.l2address === requiredTokenAddress) continue;
+        const tokenInfo = swappableTokens.find((token)=>token.address === addresses.l2address);
+        if (!tokenInfo) continue;
+        filteredSwappableTokens.push(tokenInfo);
+    }
+    return filteredSwappableTokens;
+};
+// Modifies a users balance to include the amount as if the user successfully bridged
+// This is so the swap route can check against the balance once the user has performed a bridge
+const $afd57acae9471ac5$var$modifyTokenBalancesWithBridgedAmount = (config, tokenBalances, l2balances, bridgedTokens, swappableTokens)=>{
+    const modifiedTokenBalances = new Map();
+    for (const [chainId, tokenBalance] of tokenBalances)modifiedTokenBalances.set(chainId, {
+        success: tokenBalance.success,
+        balances: tokenBalance.balances
+    });
+    // Construct a map of balances to the L2 token address to make
+    // it easier to adjust the balances for the tokens that can be bridged
+    const balanceMap = new Map();
+    for (const balance of l2balances){
+        if (!balance.token.address) continue;
+        balanceMap.set(balance.token.address, balance);
+    }
+    // Go through each of the tokens that can be bridged
+    // and adjust the balances to fake the bridge
+    for (const bridgedToken of bridgedTokens){
+        const { amount: amount, l2address: l2address } = bridgedToken;
+        if (l2address === "") continue;
+        let l2balance = (BigNumber$1).from(0);
+        // Find the current balance of this token
+        const currentBalance = balanceMap.get(l2address);
+        if (currentBalance) l2balance = currentBalance.balance;
+        const newBalance = l2balance.add(amount);
+        const tokenInfo = swappableTokens.find((token)=>token.address === l2address);
+        balanceMap.set(l2address, {
+            balance: newBalance,
+            formattedBalance: (utils$1).formatUnits(newBalance, tokenInfo.decimals),
+            token: tokenInfo
+        });
+    }
+    const updatedBalances = Array.from(balanceMap.values());
+    modifiedTokenBalances.set(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config), {
+        success: true,
+        balances: updatedBalances
+    });
+    return modifiedTokenBalances;
+};
+const $afd57acae9471ac5$export$1fc63300bde5e690 = (tokenBalances, swapRoutes)=>{
+    const originalSwapSteps = [];
+    for (const route of swapRoutes){
+        const { chainId: chainId, asset: asset } = route;
+        const tokenBalance = tokenBalances.get(chainId);
+        if (!tokenBalance) continue;
+        let originalBalance = (BigNumber$1).from(0);
+        let originalFormattedBalance = "0";
+        const l2balance = tokenBalance.balances.find((balance)=>balance.token.address === asset.token.address);
+        if (l2balance) {
+            originalBalance = l2balance.balance;
+            originalFormattedBalance = l2balance.formattedBalance;
+        }
+        route.asset.balance = originalBalance;
+        route.asset.formattedBalance = originalFormattedBalance;
+        originalSwapSteps.push(route);
+    }
+    return originalSwapSteps;
+};
+const $afd57acae9471ac5$export$d9b96654eebdaf2a = (bridgeFundingSteps, swapFundingSteps, l1tol2Addresses)=>{
+    const bridgeAndSwapRoutes = [];
+    for (const bridgeFundingStep of bridgeFundingSteps){
+        if (!bridgeFundingStep) continue;
+        const mapping = l1tol2Addresses.find((addresses)=>{
+            if (bridgeFundingStep.asset.token.address === undefined) return addresses.l1address === ($887d24b47765b1c0$export$c37d8687c27b9660) && addresses.l2address;
+            return addresses.l1address === bridgeFundingStep.asset.token.address && addresses.l2address;
+        });
+        if (!mapping) continue;
+        const swapFundingStep = swapFundingSteps.find((step)=>step.asset.token.address === mapping.l2address);
+        if (!swapFundingStep) continue;
+        bridgeAndSwapRoutes.push({
+            bridgeFundingStep: bridgeFundingStep,
+            swapFundingStep: swapFundingStep
+        });
+    }
+    return bridgeAndSwapRoutes;
+};
+const $afd57acae9471ac5$export$f95ed27e871fe308 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, 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 [];
+    // Fetch L2 to L1 address mapping and based on the L1 address existing then
+    // filter the bridgeable and swappable tokens list further to only include
+    // tokens that can be both swapped and bridged
+    const l1tol2Addresses = await ($7500587317643fc8$export$c3e193fd573f1a94)(config, swappableTokens);
+    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);
+    // 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 [];
+    // Create a mapping of bridge routes to L2 addresses
+    const bridgePromises = new Map();
+    // Create map of bridgeable tokens to make it easier to get the amount that was bridged when modifying the users balance later
+    const bridgeableRequirementsMap = new Map();
+    const bridgedTokens = [];
+    for (const bridgeRequirement of bridgeRequirements){
+        if (!bridgeRequirement.l2address) continue;
+        bridgePromises.set(bridgeRequirement.l2address, ($fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa)(config, readOnlyProviders, ownerAddress, availableRoutingOptions, bridgeRequirement, tokenBalances, feeEstimates));
+        bridgeableRequirementsMap.set(bridgeRequirement.l2address, {
+            amount: bridgeRequirement.amount,
+            formattedAmount: bridgeRequirement.formattedAmount,
+            l2address: bridgeRequirement.l2address
+        });
+    }
+    const bridgeResults = await Promise.all(bridgePromises.values());
+    const bridgeKeys = Array.from(bridgePromises.keys());
+    // Create an array to store all the tokens that are able to be bridged
+    const swappableTokensAfterBridging = [];
+    // Iterate through all the bridge route results
+    // If a bridge route result was successful then add this token to the
+    // list of tokens that should be checked with the swap route
+    bridgeResults.forEach((result, index)=>{
+        const key = bridgeKeys[index];
+        if (result === undefined) return;
+        swappableTokensAfterBridging.push(key);
+        const bridgedToken = bridgeableRequirementsMap.get(key);
+        if (!bridgedToken) return;
+        bridgedTokens.push({
+            amount: bridgedToken.amount,
+            formattedAmount: bridgedToken.formattedAmount,
+            l2address: bridgedToken.l2address
+        });
+    });
+    // Bridge route determined that no tokens could be bridged
+    if (swappableTokensAfterBridging.length === 0) return [];
+    if (bridgedTokens.length === 0) return []; // No tokens were bridged
+    // 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);
+    if (!swapRoutes) return [];
+    const originalBalanceSwapRoutes = $afd57acae9471ac5$export$1fc63300bde5e690(tokenBalances, swapRoutes);
+    return $afd57acae9471ac5$export$d9b96654eebdaf2a(bridgeResults, originalBalanceSwapRoutes, l1tol2Addresses);
+};
+
 
 
 
@@ -30648,6 +30945,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;
@@ -30659,6 +30957,18 @@ const $c16168a9c28ae4fd$export$31ce7ba1a2956195 = (balanceRequirements)=>{
     if (insufficientBalanceCount === 1) return insufficientRequirement;
     return undefined;
 };
+const $c16168a9c28ae4fd$export$ab86023c267660 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, ownerAddress, tokenBalances, feeEstimates)=>{
+    let bridgeFundingStep;
+    if (insufficientRequirement === undefined) return undefined;
+    if (insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE && insufficientRequirement.type !== ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return undefined;
+    const bridgeRequirement = {
+        amount: insufficientRequirement.delta.balance,
+        formattedAmount: insufficientRequirement.delta.formattedBalance,
+        l2address: insufficientRequirement.required.token.address ?? ""
+    };
+    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)=>{
     const fundingSteps = [];
     if (!availableRoutingOptions.swap) return fundingSteps;
@@ -30672,6 +30982,27 @@ const $c16168a9c28ae4fd$export$814624e957fa0f11 = async (config, availableRoutin
     if (swappableTokens.length === 0) return fundingSteps;
     return await ($91807edfd7057288$export$8e03ea04d59f2402)(config, availableRoutingOptions, dexQuoteCache, ownerAddress, insufficientRequirement, tokenBalances, swappableTokens);
 };
+const $c16168a9c28ae4fd$export$2becd43da9d21f73 = async (config, readOnlyProviders, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, tokenAllowList, feeEstimates, balanceRequirements)=>{
+    if (!insufficientRequirement) return [];
+    const l1balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config));
+    const l2balancesResult = tokenBalances.get(($4013c5c91bb535f6$export$c9af4e4b001c6476)(config));
+    // If there are no l1 balance then cannot bridge
+    if (!l1balancesResult) return [];
+    if (l1balancesResult.error !== undefined || !l1balancesResult.success) return [];
+    // If there are no l2 balance then cannot swap
+    if (!l2balancesResult) return [];
+    if (l2balancesResult.error !== undefined || !l2balancesResult.success) return [];
+    // Get a list of all the swappable tokens
+    const bridgeTokenAllowList = tokenAllowList?.bridge ?? [];
+    const bridgeableL1Addresses = bridgeTokenAllowList.map((token)=>{
+        if (token.address === undefined) return $887d24b47765b1c0$export$c37d8687c27b9660;
+        return token.address;
+    });
+    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);
+    return routes;
+};
 const $c16168a9c28ae4fd$export$e1b6e4d22d0365ee = async (config, availableRoutingOptions, insufficientRequirement)=>{
     if (!availableRoutingOptions.onRamp) return undefined;
     if (insufficientRequirement === undefined) return undefined;
@@ -30700,16 +31031,24 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
     const feeEstimates = new Map();
     // Dex quotes cache
     const dexQuoteCache = new Map();
-    // Ensures only 1 balance requirement is insufficient otherwise one bridge or one swap route cannot be recommended
+    // 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));
+    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);
     let bridgeFundingStep;
-    if (availableRoutingOptions.bridge && insufficientRequirement) bridgeFundingStep = await ($fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa)(config, readOnlyProviders, ownerAddress, availableRoutingOptions, insufficientRequirement, tokenBalances, feeEstimates);
-    const swapFundingSteps = await $c16168a9c28ae4fd$export$814624e957fa0f11(config, availableRoutingOptions, insufficientRequirement, dexQuoteCache, ownerAddress, tokenBalances, allowList.swap);
-    const onRampFundingStep = await $c16168a9c28ae4fd$export$e1b6e4d22d0365ee(config, availableRoutingOptions, insufficientRequirement);
-    // Check swap routes
-    // > Could bridge first
-    // > Could on-ramp first
-    // > Could double swap
+    let swapFundingSteps = [];
+    let onRampFundingStep;
+    let bridgeAndSwapFundingSteps = [];
+    resolved.forEach((result, index)=>{
+        if (index === 0) bridgeFundingStep = result;
+        if (index === 1) swapFundingSteps = result;
+        if (index === 2) onRampFundingStep = result;
+        if (index === 3) bridgeAndSwapFundingSteps = result;
+    });
     const response = {
         response: {
             type: ($b23305044c0e096a$export$3057de18ac0c076).NO_ROUTES,
@@ -30718,7 +31057,7 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
         fundingRoutes: []
     };
     let priority = 0;
-    if (bridgeFundingStep || swapFundingSteps.length > 0 || onRampFundingStep) {
+    if (bridgeFundingStep || swapFundingSteps.length > 0 || onRampFundingStep || bridgeAndSwapFundingSteps.length > 0) {
         response.response.type = ($b23305044c0e096a$export$3057de18ac0c076).ROUTES_FOUND;
         response.response.message = "Routes found";
     }
@@ -30751,6 +31090,22 @@ const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, b
             ]
         });
     }
+    if (bridgeAndSwapFundingSteps) {
+        priority++;
+        bridgeAndSwapFundingSteps.forEach((bridgeAndSwapFundingStep)=>{
+            const bridgeStep = bridgeAndSwapFundingStep.bridgeFundingStep;
+            const swapStep = bridgeAndSwapFundingStep.swapFundingStep;
+            response.fundingRoutes.push({
+                priority: priority,
+                steps: [
+                    bridgeStep,
+                    swapStep
+                ]
+            });
+        });
+    }
+    // eslint-disable-next-line no-console
+    console.log("** response", response);
     return response;
 };
 
@@ -30925,7 +31280,6 @@ const $a7367d01c6e76b1c$export$d62081fac18000c2 = (orderHash, orderComponents, a
 
 
 
-
 const $9051cee080948594$export$9ac1563efd38130 = 1; // 100%
 const $9051cee080948594$export$768e717351d4b176 = 6; // will allow 0.000001 (0.0001%) as the minimum value
 const $9051cee080948594$var$calculateFeesPercent = (orderFee, amountBn)=>{
@@ -30937,7 +31291,7 @@ const $9051cee080948594$var$calculateFeesPercent = (orderFee, amountBn)=>{
 };
 const $9051cee080948594$var$calculateFeesToken = (orderFee, decimals)=>{
     const feeToken = orderFee.amount;
-    const bnFeeAmount = (parseUnits$1)(feeToken.token, decimals);
+    const bnFeeAmount = (utils$1).parseUnits(feeToken.token, decimals);
     return bnFeeAmount;
 };
 const $9051cee080948594$export$1e69c9cfc42e28d8 = (orderFees, weiAmount, decimals = 18)=>{
@@ -31169,7 +31523,6 @@ const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, order
 
 
 
-
 const $9085b221b72ac69e$export$af768ccdf17d5c04 = (id, contractAddress, spenderAddress)=>({
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC721,
         id: id,
@@ -31177,7 +31530,7 @@ const $9085b221b72ac69e$export$af768ccdf17d5c04 = (id, contractAddress, spenderA
         spenderAddress: spenderAddress
     });
 const $9085b221b72ac69e$export$586d02673c66d423 = (buyToken, decimals = 18)=>{
-    const bnAmount = (parseUnits$1)(buyToken.amount, decimals);
+    const bnAmount = (utils$1).parseUnits(buyToken.amount, decimals);
     if (buyToken.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return {
         type: ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE,
         amount: bnAmount.toString()
@@ -31358,11 +31711,11 @@ async function $d35036efee31c5d1$export$dc8635800ef20f4b(provider, requirements)
     const itemRequirements = requirements.map((itemRequirementParam, index)=>{
         if (itemRequirementParam.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).NATIVE) return {
             ...itemRequirementParam,
-            amount: (parseUnits$1)(itemRequirementParam.amount, 18)
+            amount: (utils$1).parseUnits(itemRequirementParam.amount, 18)
         };
         if (itemRequirementParam.type === ($4b58188d47aafe8d$export$1fc8f52ad1810e52).ERC20) return {
             ...itemRequirementParam,
-            amount: (parseUnits$1)(itemRequirementParam.amount, decimals[index])
+            amount: (utils$1).parseUnits(itemRequirementParam.amount, decimals[index])
         };
         return itemRequirementParam;
     });
@@ -31621,7 +31974,7 @@ var checkout_sdk = /*#__PURE__*/Object.freeze({
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.22.0";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.22.1";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 
@@ -31686,6 +32039,7 @@ var $207ed853f11d19d5$export$5a0ace85cae72d45;
     IMTBLWidgetEvents["IMTBL_SWAP_WIDGET_EVENT"] = "imtbl-swap-widget";
     IMTBLWidgetEvents["IMTBL_BRIDGE_WIDGET_EVENT"] = "imtbl-bridge-widget";
     IMTBLWidgetEvents["IMTBL_ONRAMP_WIDGET_EVENT"] = "imtbl-onramp-widget";
+    IMTBLWidgetEvents["IMTBL_PRIMARY_REVENUE_WIDGET_EVENT"] = "imtbl-primary-revenue-widget";
 })($207ed853f11d19d5$export$5a0ace85cae72d45 || ($207ed853f11d19d5$export$5a0ace85cae72d45 = {}));
 
 
@@ -31725,6 +32079,20 @@ $parcel$export($53d219e7f6bf0cd6$exports, "SwapEventType", () => $53d219e7f6bf0c
 })($53d219e7f6bf0cd6$export$140a49745ab55563 || ($53d219e7f6bf0cd6$export$140a49745ab55563 = {}));
 
 
+var $8c83f59522c4ca40$exports = {};
+
+$parcel$export($8c83f59522c4ca40$exports, "PrimaryRevenueEventType", () => $8c83f59522c4ca40$export$b33478ffb988bd5e);
+/**
+ * Enum representing possible Primary Revenue Widget event types.
+ */ var $8c83f59522c4ca40$export$b33478ffb988bd5e;
+(function(PrimaryRevenueEventType) {
+    PrimaryRevenueEventType["CLOSE_WIDGET"] = "close-widget";
+    PrimaryRevenueEventType["SUCCESS"] = "success";
+    PrimaryRevenueEventType["FAILURE"] = "failure";
+    PrimaryRevenueEventType["REJECTED"] = "rejected";
+})($8c83f59522c4ca40$export$b33478ffb988bd5e || ($8c83f59522c4ca40$export$b33478ffb988bd5e = {}));
+
+
 var $15cc9e120aa6f3bf$exports = {};
 
 $parcel$export($15cc9e120aa6f3bf$exports, "BridgeEventType", () => $15cc9e120aa6f3bf$export$d1bfa21f7c76447a);
@@ -31991,6 +32359,7 @@ var checkout_widgets = /*#__PURE__*/Object.freeze({
     get OnRampEventType () { return $d882ddc5600b1284$export$66ec39c0924078d8; },
     OnRampReact: $f94f63f2c041a04c$export$9e363c61ea99bbb4,
     get OrchestrationEventType () { return $ad06b030b1a3ba34$export$b80d2daf830437b9; },
+    get PrimaryRevenueEventType () { return $8c83f59522c4ca40$export$b33478ffb988bd5e; },
     get SwapEventType () { return $53d219e7f6bf0cd6$export$140a49745ab55563; },
     SwapReact: $a4fbb8e3a6aeff58$export$971e031379577f4,
     UpdateConfig: $430e3eda76fa4d5f$export$bf1548ba7e61c17f,