@imtbl/sdk 0.17.4 → 0.17.6

package/dist/index.cjs

@@ -2724,7 +2724,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.17.4' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.17.6' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -2784,7 +2784,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.17.4',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.17.6',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -3070,7 +3070,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.17.4',
+    sdkVersion: 'ts-immutable-sdk-0.17.6',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -27832,6 +27832,7 @@ var $e055e79256bbc1dd$export$80f4da0d409a629d;
     CheckoutErrorType["EXECUTE_APPROVAL_TRANSACTION_ERROR"] = "EXECUTE_APPROVAL_TRANSACTION_ERROR";
     CheckoutErrorType["EXECUTE_FULFILMENT_TRANSACTION_ERROR"] = "EXECUTE_FULFILMENT_TRANSACTION_ERROR";
     CheckoutErrorType["SIGN_MESSAGE_ERROR"] = "SIGN_MESSAGE_ERROR";
+    CheckoutErrorType["BRIDGE_GAS_ESTIMATE_ERROR"] = "BRIDGE_GAS_ESTIMATE_ERROR";
 })($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
 class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
     message;
@@ -28639,6 +28640,7 @@ async function $570856c68db0bd36$export$9e73e22953cebcfc(tokenBridge, tokenAddre
 
 
 
+
 async function $67fc622a2b913d5f$export$989eefe1274a439c(fromChainId, toChainId, readOnlyProviders, config) {
     const rootChainProvider = readOnlyProviders.get(fromChainId);
     const childChainProvider = readOnlyProviders.get(toChainId);
@@ -28674,6 +28676,13 @@ async function $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config) {
         }
     });
 }
+function $67fc622a2b913d5f$export$436dd76f23f463ff(config) {
+    return new (BlockchainData)({
+        baseConfig: {
+            environment: config.environment
+        }
+    });
+}
 
 
 
@@ -29427,8 +29436,8 @@ const $7d1bfafb81e64d74$export$3a4140bd9e983e4e = async (provider, insufficientI
 
 
 
-const $1fda5c40669a566d$export$1fac8e857d728583 = async ()=>true;
-const $1fda5c40669a566d$export$2e83e9eeaf217e20 = async ()=>true;
+const $1fda5c40669a566d$export$1fac8e857d728583 = async ()=>false;
+const $1fda5c40669a566d$export$2e83e9eeaf217e20 = async ()=>false;
 
 
 const $7f2e17f026d4fc8d$var$isPassportProvider = (provider)=>(provider.provider?.isPassport === true) ?? false;
@@ -29464,43 +29473,30 @@ const $7f2e17f026d4fc8d$export$f1ca3744c025ab81 = async (config, provider)=>{
 
 
 
+var $b23305044c0e096a$export$3057de18ac0c076;
+(function(RouteCalculatorType) {
+    RouteCalculatorType["ROUTES_FOUND"] = "ROUTES_FOUND";
+    RouteCalculatorType["NO_ROUTES"] = "NO_ROUTES";
+    RouteCalculatorType["NO_OPTIONS"] = "NO_OPTIONS";
+})($b23305044c0e096a$export$3057de18ac0c076 || ($b23305044c0e096a$export$3057de18ac0c076 = {}));
+var $b23305044c0e096a$export$3af78bb3e8650ee6;
+(function(FundingRouteType) {
+    FundingRouteType["BRIDGE"] = "BRIDGE";
+    FundingRouteType["ON_RAMP"] = "ONRAMP";
+    FundingRouteType["SWAP"] = "SWAP";
+})($b23305044c0e096a$export$3af78bb3e8650ee6 || ($b23305044c0e096a$export$3af78bb3e8650ee6 = {}));
 
 
 
 
 
-async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnlyProviders) {
-    if (config.isProduction && existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM)) return existingReadOnlyProviders;
-    if (existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA)) return existingReadOnlyProviders;
-    const readOnlyProviders = new Map();
-    const allowedNetworks = await $de192de6ef100f9f$export$3043f6442a9ef563(config, {
-        type: ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL
-    });
-    allowedNetworks.networks.forEach((networkInfo)=>{
-        const rpcUrl = config.networkMap.get(networkInfo.chainId)?.rpcUrls[0];
-        const provider = new (providers.JsonRpcProvider)(rpcUrl);
-        readOnlyProviders.set(networkInfo.chainId, provider);
-    });
-    return readOnlyProviders;
-}
-
-
-
-
-const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, ownerAddress, availableRoutingOptions)=>{
+const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, readOnlyProviders, ownerAddress, availableRoutingOptions)=>{
     const chainBalances = new Map();
     const chainBalancePromises = new Map();
-    let readOnlyProviders = new Map();
-    let providerError;
-    try {
-        readOnlyProviders = await (0, $0e0060cb42e136d2$export$339cb2be73677b30)(config);
-    } catch (error) {
-        providerError = error;
-    }
     if (readOnlyProviders.size === 0) {
         const noProviderResult = {
             success: false,
-            error: providerError || new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider failed", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR),
+            error: new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No L1 or L2 provider available", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR),
             balances: []
         };
         chainBalances.set(($4013c5c91bb535f6$export$9b794d067cdd1af6)(config), noProviderResult);
@@ -29544,44 +29540,263 @@ const $33acec7b4a26c053$export$23ddeb2642d2f9d = async (config, ownerAddress, av
 };
 
 
+/* 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 (ethers.BigNumber).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, ethers.BigNumber).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 = (chainId)=>{
+    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA) return "0x2Fa06C6672dDCc066Ab04631192738799231dE4a";
+    if (chainId === ($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM) return "0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF";
+    return "";
+};
+
+
+
+
+
+
+
+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, ethers.BigNumber).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 (ethers.BigNumber).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$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 $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 ($823db9fb0ca4bc15$export$53e663abd9b77fc1)(($4013c5c91bb535f6$export$9b794d067cdd1af6)(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(($b23305044c0e096a$export$3af78bb3e8650ee6).BRIDGE);
+    if (bridgeFeeEstimate) return bridgeFeeEstimate;
+    bridgeFeeEstimate = await ($8a49d1a3783a2640$export$3aff971444a4f244)(config, readOnlyProviders);
+    feeEstimates.set(($b23305044c0e096a$export$3af78bb3e8650ee6).BRIDGE, bridgeFeeEstimate);
+    return bridgeFeeEstimate;
+};
+const $fa9ac5bfdbbf9dfa$var$constructBridgeFundingRoute = (chainId, balance)=>({
+        type: ($b23305044c0e096a$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;
+};
+
+
+
+
+
+async function $0e0060cb42e136d2$export$339cb2be73677b30(config, existingReadOnlyProviders) {
+    if (config.isProduction && existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).ETHEREUM)) return existingReadOnlyProviders;
+    if (existingReadOnlyProviders?.has(($0472f23319457bfb$export$c06e1e7429de6283).SEPOLIA)) return existingReadOnlyProviders;
+    const readOnlyProviders = new Map();
+    const allowedNetworks = await $de192de6ef100f9f$export$3043f6442a9ef563(config, {
+        type: ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL
+    });
+    allowedNetworks.networks.forEach((networkInfo)=>{
+        const rpcUrl = config.networkMap.get(networkInfo.chainId)?.rpcUrls[0];
+        const provider = new (providers.JsonRpcProvider)(rpcUrl);
+        readOnlyProviders.set(networkInfo.chainId, provider);
+    });
+    return readOnlyProviders;
+}
+
+
+
+const $c16168a9c28ae4fd$export$31ce7ba1a2956195 = (balanceRequirements)=>{
+    let insufficientBalanceCount = 0;
+    let insufficientBridgeRequirement;
+    for (const balanceRequirement of balanceRequirements.balanceRequirements)if (!balanceRequirement.sufficient) {
+        insufficientBalanceCount++;
+        insufficientBridgeRequirement = balanceRequirement;
+    }
+    if (insufficientBalanceCount === 1) return insufficientBridgeRequirement;
+    return undefined;
+};
 const $c16168a9c28ae4fd$export$92606e71d0a264ff = async (config, ownerAddress, balanceRequirements, availableRoutingOptions)=>{
-    // eslint-disable-next-line no-console
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    await ($33acec7b4a26c053$export$23ddeb2642d2f9d)(config, ownerAddress, availableRoutingOptions);
-    // Get allowed tokens?
-    // Check bridging routes
+    let readOnlyProviders;
+    try {
+        readOnlyProviders = await (0, $0e0060cb42e136d2$export$339cb2be73677b30)(config);
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error occurred while creating read only providers", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_ERROR, {
+            message: err.message
+        });
+    }
+    const tokenBalances = await ($33acec7b4a26c053$export$23ddeb2642d2f9d)(config, readOnlyProviders, ownerAddress, availableRoutingOptions);
+    // Bridge and swap fee cache
+    const feeEstimates = new Map();
+    // Ensures only 1 balance requirement is insufficient otherwise one bridge route cannot be recommended
+    let bridgeFundingStep;
+    const insufficientRequirement = $c16168a9c28ae4fd$export$31ce7ba1a2956195(balanceRequirements);
+    if (availableRoutingOptions.bridge && insufficientRequirement) bridgeFundingStep = await ($fa9ac5bfdbbf9dfa$export$ddc7ba2b57d7c5fa)(config, readOnlyProviders, ownerAddress, availableRoutingOptions, insufficientRequirement, tokenBalances, feeEstimates);
     // Check on-ramp routes
     // Check swap routes
     // > Could bridge first
     // > Could on-ramp first
     // > Could double swap
-    return {
+    if (bridgeFundingStep) return {
         availableOptions: [],
         response: {
-            type: "ROUTES_FOUND",
+            type: ($b23305044c0e096a$export$3057de18ac0c076).ROUTES_FOUND,
             message: "Routes found"
         },
         fundingRoutes: [
             {
                 priority: 1,
                 steps: [
-                    {
-                        type: "bridge",
-                        chainId: 1,
-                        asset: {
-                            balance: (ethers.BigNumber).from(0),
-                            formattedBalance: "0",
-                            token: {
-                                name: "ETH",
-                                symbol: "ETH",
-                                decimals: 18
-                            }
-                        }
-                    }
+                    bridgeFundingStep
                 ]
             }
         ]
     };
+    return {
+        availableOptions: [],
+        response: {
+            type: ($b23305044c0e096a$export$3057de18ac0c076).NO_ROUTES,
+            message: "Routes not found"
+        },
+        fundingRoutes: []
+    };
 };
 
 
@@ -30294,7 +30509,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.17.4";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.17.6";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/index.d.ts

@@ -14520,6 +14520,7 @@ interface CheckoutModuleConfiguration extends ModuleConfiguration<CheckoutOverri
 type RemoteConfiguration = {
     dex: DexConfig;
     onramp: OnRampConfig;
+    bridge: BridgeConfig;
     allowedNetworks: AllowedNetworkConfig[];
     gasEstimateTokens?: GasEstimateTokenConfig;
 };
@@ -14561,6 +14562,13 @@ type DexConfig = {
     overrides?: ExchangeOverrides;
     tokens?: TokenInfo[];
 };
+/**
+ * A type representing the configuration for the Bridge.
+ * @property {TokenInfo[] | undefined} tokens - An array of tokens compatible with the Bridge.
+ */
+type BridgeConfig = {
+    tokens?: TokenInfo[];
+};
 /**
  * A type representing an allowed network.
  * @property {number} chainId - The network chain id.
@@ -15052,7 +15060,8 @@ declare enum CheckoutErrorType {
     GET_ERC721_ALLOWANCE_ERROR = "GET_ERC721_ALLOWANCE_ERROR",
     EXECUTE_APPROVAL_TRANSACTION_ERROR = "EXECUTE_APPROVAL_TRANSACTION_ERROR",
     EXECUTE_FULFILMENT_TRANSACTION_ERROR = "EXECUTE_FULFILMENT_TRANSACTION_ERROR",
-    SIGN_MESSAGE_ERROR = "SIGN_MESSAGE_ERROR"
+    SIGN_MESSAGE_ERROR = "SIGN_MESSAGE_ERROR",
+    BRIDGE_GAS_ESTIMATE_ERROR = "BRIDGE_GAS_ESTIMATE_ERROR"
 }
 /**
  * Represents an error object with a specific type, optional message, and optional data.