@imtbl/sdk 0.17.4 → 0.17.5

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.5' };
 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.5',
 };
 /**
  * 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.5',
 });
 /**
  * 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
+        }
+    });
+}
 
 
 
@@ -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,243 @@ 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 $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) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Error getting balances", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_BALANCE_ERROR, {
+        chainId: chainId.toString()
+    });
+    if (tokenBalanceResult.balances.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;
+    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);
+    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);
     // Get allowed tokens?
-    // Check bridging routes
+    // 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 +30489,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.5";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/index.d.ts

@@ -15052,7 +15052,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.