@imtbl/sdk 0.36.3 → 0.36.5

package/dist/index.cjs

@@ -4256,7 +4256,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.36.3' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.36.5' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -4316,7 +4316,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.36.3',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.36.5',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4755,7 +4755,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.36.3',
+    sdkVersion: 'ts-immutable-sdk-0.36.5',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -17490,105 +17490,6 @@ axios.default = axios;
 // this module should only have a default export
 var axios$1 = axios;
 
-/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * @constant {string} ETH_SEPOLIA_CHAIN_ID - The chain ID for the Ethereum Sepolia testnet (EIP-155 compatible format).
- */
-const ETH_SEPOLIA_CHAIN_ID = '11155111';
-/**
- * @constant {string} ETH_MAINNET_CHAIN_ID - The chain ID for the Ethereum mainnet (EIP-155 compatible format).
- */
-const ETH_MAINNET_CHAIN_ID = '1';
-/**
- * @constant {string} ZKEVM_DEVNET_CHAIN_ID - The chain ID for the zkEVM devnet (EIP-155 compatible format).
- */
-const ZKEVM_DEVNET_CHAIN_ID = '15003';
-/**
- * @constant {string} ZKEVM_TESTNET_CHAIN_ID - The chain ID for the zkEVM testnet (EIP-155 compatible format).
- */
-const ZKEVM_TESTNET_CHAIN_ID = '13473';
-/**
- * @constant {string} ZKEVM_MAINNET_CHAIN_ID - The chain ID for the zkEVM mainnet (EIP-155 compatible format).
- */
-const ZKEVM_MAINNET_CHAIN_ID = '13371'; // @TODO confirm this is still correct
-/**
- * @constant {BridgeInstance} ETH_SEPOLIA_TO_ZKEVM_DEVNET - A bridge instance configuration for bridging between
- * the Ethereum Sepolia testnet and the zkEVM devnet.
- */
-const ETH_SEPOLIA_TO_ZKEVM_DEVNET = {
-    rootChainID: ETH_SEPOLIA_CHAIN_ID,
-    childChainID: ZKEVM_DEVNET_CHAIN_ID,
-};
-/**
- * @constant {BridgeInstance} ETH_SEPOLIA_TO_ZKEVM_TESTNET - A bridge instance configuration for bridging
- * between the Ethereum Sepolia testnet and the zkEVM testnet.
- */
-const ETH_SEPOLIA_TO_ZKEVM_TESTNET = {
-    rootChainID: ETH_SEPOLIA_CHAIN_ID,
-    childChainID: ZKEVM_TESTNET_CHAIN_ID,
-};
-/**
- * @constant {BridgeInstance} ETH_MAINNET_TO_ZKEVM_MAINNET - A bridge instance configuration for bridging
- * between the Ethereum mainnet and the zkEVM mainnet.
- */
-const ETH_MAINNET_TO_ZKEVM_MAINNET = {
-    rootChainID: ETH_MAINNET_CHAIN_ID,
-    childChainID: ZKEVM_MAINNET_CHAIN_ID,
-};
-/**
- * @typedef {Object} axelarAPIEndpoints - API endpoints for the testnet & mainnet Axelar environment configurations
- */
-const axelarAPIEndpoints = {
-    testnet: 'https://testnet.api.gmp.axelarscan.io',
-    mainnet: 'https://api.gmp.axelarscan.io',
-    devnet: '',
-};
-/**
- * @typedef {Object} axelarChains
- * @property {AxelarChainDetails} [chainId] - Mapping of the ChainId to the Axelar chain id string and symbol.
- */
-const axelarChains = {
-    11155111: {
-        id: 'ethereum-sepolia',
-        symbol: 'ETH',
-    },
-    1: {
-        id: 'ethereum',
-        symbol: 'ETH',
-    },
-    15003: {
-        id: 'immutable',
-        symbol: 'IMX',
-    },
-    13473: {
-        id: 'immutable',
-        symbol: 'IMX',
-    },
-    13371: {
-        id: 'immutable',
-        symbol: 'IMX',
-    }, // immutable zkevm mainnet
-};
-/**
- * @typedef {Object} bridgeMethods
- * @property {string} deposit - The set of contract methods for depositing.
- * @property {string} withdraw - The set of contract methods for withdrawing.
- */
-const bridgeMethods = {
-    deposit: {
-        token: 'deposit',
-        tokenTo: 'depositTo',
-        native: 'depositETH',
-        nativeTo: 'depositToETH',
-    },
-    withdraw: {
-        token: 'withdraw',
-        tokenTo: 'withdrawTo',
-        native: 'withdrawIMX',
-        nativeTo: 'withdrawIMXTo',
-    },
-};
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -26775,6 +26676,105 @@ function parseUnits(value, unitName) {
     return parseFixed(value, (unitName != null) ? unitName : 18);
 }
 
+/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * @constant {string} ETH_SEPOLIA_CHAIN_ID - The chain ID for the Ethereum Sepolia testnet (EIP-155 compatible format).
+ */
+const ETH_SEPOLIA_CHAIN_ID = '11155111';
+/**
+ * @constant {string} ETH_MAINNET_CHAIN_ID - The chain ID for the Ethereum mainnet (EIP-155 compatible format).
+ */
+const ETH_MAINNET_CHAIN_ID = '1';
+/**
+ * @constant {string} ZKEVM_DEVNET_CHAIN_ID - The chain ID for the zkEVM devnet (EIP-155 compatible format).
+ */
+const ZKEVM_DEVNET_CHAIN_ID = '15003';
+/**
+ * @constant {string} ZKEVM_TESTNET_CHAIN_ID - The chain ID for the zkEVM testnet (EIP-155 compatible format).
+ */
+const ZKEVM_TESTNET_CHAIN_ID = '13473';
+/**
+ * @constant {string} ZKEVM_MAINNET_CHAIN_ID - The chain ID for the zkEVM mainnet (EIP-155 compatible format).
+ */
+const ZKEVM_MAINNET_CHAIN_ID = '13371'; // @TODO confirm this is still correct
+/**
+ * @constant {BridgeInstance} ETH_SEPOLIA_TO_ZKEVM_DEVNET - A bridge instance configuration for bridging between
+ * the Ethereum Sepolia testnet and the zkEVM devnet.
+ */
+const ETH_SEPOLIA_TO_ZKEVM_DEVNET = {
+    rootChainID: ETH_SEPOLIA_CHAIN_ID,
+    childChainID: ZKEVM_DEVNET_CHAIN_ID,
+};
+/**
+ * @constant {BridgeInstance} ETH_SEPOLIA_TO_ZKEVM_TESTNET - A bridge instance configuration for bridging
+ * between the Ethereum Sepolia testnet and the zkEVM testnet.
+ */
+const ETH_SEPOLIA_TO_ZKEVM_TESTNET = {
+    rootChainID: ETH_SEPOLIA_CHAIN_ID,
+    childChainID: ZKEVM_TESTNET_CHAIN_ID,
+};
+/**
+ * @constant {BridgeInstance} ETH_MAINNET_TO_ZKEVM_MAINNET - A bridge instance configuration for bridging
+ * between the Ethereum mainnet and the zkEVM mainnet.
+ */
+const ETH_MAINNET_TO_ZKEVM_MAINNET = {
+    rootChainID: ETH_MAINNET_CHAIN_ID,
+    childChainID: ZKEVM_MAINNET_CHAIN_ID,
+};
+/**
+ * @typedef {Object} axelarAPIEndpoints - API endpoints for the testnet & mainnet Axelar environment configurations
+ */
+const axelarAPIEndpoints = {
+    testnet: 'https://testnet.api.gmp.axelarscan.io',
+    mainnet: 'https://api.gmp.axelarscan.io',
+    devnet: '',
+};
+/**
+ * @typedef {Object} axelarChains
+ * @property {AxelarChainDetails} [chainId] - Mapping of the ChainId to the Axelar chain id string and symbol.
+ */
+const axelarChains = {
+    11155111: {
+        id: 'ethereum-sepolia',
+        symbol: 'ETH',
+    },
+    1: {
+        id: 'ethereum',
+        symbol: 'ETH',
+    },
+    15003: {
+        id: 'immutable',
+        symbol: 'IMX',
+    },
+    13473: {
+        id: 'immutable',
+        symbol: 'IMX',
+    },
+    13371: {
+        id: 'immutable',
+        symbol: 'IMX',
+    }, // immutable zkevm mainnet
+};
+/**
+ * @typedef {Object} bridgeMethods
+ * @property {string} deposit - The set of contract methods for depositing.
+ * @property {string} withdraw - The set of contract methods for withdrawing.
+ */
+const bridgeMethods = {
+    deposit: {
+        token: 'deposit',
+        tokenTo: 'depositTo',
+        native: 'depositETH',
+        nativeTo: 'depositToETH',
+    },
+    withdraw: {
+        token: 'withdraw',
+        tokenTo: 'withdrawTo',
+        native: 'withdrawIMX',
+        nativeTo: 'withdrawIMXTo',
+    },
+};
+
 const ROOT_ERC20_BRIDGE_FLOW_RATE = [
     {
         inputs: [
@@ -29035,6 +29035,7 @@ var BridgeErrorType;
     BridgeErrorType["AXELAR_CHAIN_NOT_FOUND"] = "AXELAR_CHAIN_NOT_FOUND";
     BridgeErrorType["AXELAR_GAS_ESTIMATE_FAILED"] = "AXELAR_GAS_ESTIMATE_FAILED";
     BridgeErrorType["INVALID_RECIPIENT"] = "INVALID_RECIPIENT";
+    BridgeErrorType["FLOW_RATE_ERROR"] = "FLOW_RATE_ERROR";
 })(BridgeErrorType || (BridgeErrorType = {}));
 /**
  * Represents a custom error for bridge operations.
@@ -30347,16 +30348,17 @@ var BridgeFeeActions;
  */
 var BridgeMethodsGasLimit;
 (function (BridgeMethodsGasLimit) {
-    BridgeMethodsGasLimit[BridgeMethodsGasLimit["DEPOSIT_SOURCE"] = 500000] = "DEPOSIT_SOURCE";
-    BridgeMethodsGasLimit[BridgeMethodsGasLimit["DEPOSIT_DESTINATION"] = 700000] = "DEPOSIT_DESTINATION";
-    BridgeMethodsGasLimit[BridgeMethodsGasLimit["WITHDRAW_SOURCE"] = 400000] = "WITHDRAW_SOURCE";
-    BridgeMethodsGasLimit[BridgeMethodsGasLimit["WITHDRAW_DESTINATION"] = 700000] = "WITHDRAW_DESTINATION";
-    BridgeMethodsGasLimit[BridgeMethodsGasLimit["MAP_TOKEN_SOURCE"] = 300000] = "MAP_TOKEN_SOURCE";
-    BridgeMethodsGasLimit[BridgeMethodsGasLimit["MAP_TOKEN_DESTINATION"] = 700000] = "MAP_TOKEN_DESTINATION";
+    BridgeMethodsGasLimit[BridgeMethodsGasLimit["DEPOSIT_SOURCE"] = 200000] = "DEPOSIT_SOURCE";
+    BridgeMethodsGasLimit[BridgeMethodsGasLimit["DEPOSIT_DESTINATION"] = 200000] = "DEPOSIT_DESTINATION";
+    BridgeMethodsGasLimit[BridgeMethodsGasLimit["WITHDRAW_SOURCE"] = 200000] = "WITHDRAW_SOURCE";
+    BridgeMethodsGasLimit[BridgeMethodsGasLimit["WITHDRAW_DESTINATION"] = 250000] = "WITHDRAW_DESTINATION";
+    BridgeMethodsGasLimit[BridgeMethodsGasLimit["MAP_TOKEN_SOURCE"] = 200000] = "MAP_TOKEN_SOURCE";
+    BridgeMethodsGasLimit[BridgeMethodsGasLimit["MAP_TOKEN_DESTINATION"] = 200000] = "MAP_TOKEN_DESTINATION";
     BridgeMethodsGasLimit[BridgeMethodsGasLimit["FINALISE_WITHDRAWAL"] = 200000] = "FINALISE_WITHDRAWAL";
 })(BridgeMethodsGasLimit || (BridgeMethodsGasLimit = {}));
 var StatusResponse;
 (function (StatusResponse) {
+    StatusResponse["PENDING"] = "PENDING";
     StatusResponse["PROCESSING"] = "PROCESSING";
     StatusResponse["COMPLETE"] = "COMPLETE";
     StatusResponse["RETRY"] = "RETRY";
@@ -30365,6 +30367,109 @@ var StatusResponse;
     StatusResponse["FLOW_RATE_CONTROLLED"] = "FLOW_RATE_CONTROLLED";
 })(StatusResponse || (StatusResponse = {}));
 
+var GMPStatus;
+(function (GMPStatus) {
+    GMPStatus["SRC_GATEWAY_CALLED"] = "source_gateway_called";
+    GMPStatus["DEST_GATEWAY_APPROVED"] = "destination_gateway_approved";
+    GMPStatus["DEST_EXECUTED"] = "destination_executed";
+    GMPStatus["EXPRESS_EXECUTED"] = "express_executed";
+    GMPStatus["DEST_EXECUTE_ERROR"] = "error";
+    GMPStatus["DEST_EXECUTING"] = "executing";
+    GMPStatus["APPROVING"] = "approving";
+    GMPStatus["FORECALLED"] = "forecalled";
+    GMPStatus["FORECALLED_WITHOUT_GAS_PAID"] = "forecalled_without_gas_paid";
+    GMPStatus["NOT_EXECUTED"] = "not_executed";
+    GMPStatus["NOT_EXECUTED_WITHOUT_GAS_PAID"] = "not_executed_without_gas_paid";
+    GMPStatus["INSUFFICIENT_FEE"] = "insufficient_fee";
+    GMPStatus["UNKNOWN_ERROR"] = "unknown_error";
+    GMPStatus["CANNOT_FETCH_STATUS"] = "cannot_fetch_status";
+    GMPStatus["SRC_GATEWAY_CONFIRMED"] = "confirmed";
+})(GMPStatus || (GMPStatus = {}));
+var GasPaidStatus;
+(function (GasPaidStatus) {
+    GasPaidStatus["GAS_UNPAID"] = "gas_unpaid";
+    GasPaidStatus["GAS_PAID"] = "gas_paid";
+    GasPaidStatus["GAS_PAID_NOT_ENOUGH_GAS"] = "gas_paid_not_enough_gas";
+    GasPaidStatus["GAS_PAID_ENOUGH_GAS"] = "gas_paid_enough_gas";
+})(GasPaidStatus || (GasPaidStatus = {}));
+
+/* eslint-disable @typescript-eslint/naming-convention */
+const parseGMPStatus = (response) => {
+    const { error, status } = response;
+    if (status === 'error' && error)
+        return GMPStatus.DEST_EXECUTE_ERROR;
+    if (status === 'executed')
+        return GMPStatus.DEST_EXECUTED;
+    if (status === 'approved')
+        return GMPStatus.DEST_GATEWAY_APPROVED;
+    if (status === 'called')
+        return GMPStatus.SRC_GATEWAY_CALLED;
+    if (status === 'executing')
+        return GMPStatus.DEST_EXECUTING;
+    return status;
+};
+const parseGMPError = (response) => {
+    if (response.error) {
+        return {
+            message: response.error.error.message,
+            txHash: response.error.error.transactionHash,
+            chain: response.error.chain,
+        };
+    }
+    if (response.is_insufficient_fee) {
+        return {
+            message: 'Insufficient fee',
+            txHash: response.call.transaction.hash,
+            chain: response.call.chain,
+        };
+    }
+    return undefined;
+};
+const execGet = async (base, params) => fetch(`${base}?${new URLSearchParams(params).toString()}`, {
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json' },
+    cache: 'no-store',
+})
+    .then((res) => res.json())
+    .then((res) => res.data);
+const fetchGMPTransaction = async (axelarGMPApiUrl, txHash, txLogIndex) => execGet(axelarGMPApiUrl, {
+    method: 'searchGMP',
+    txHash,
+    txLogIndex,
+})
+    .then((data) => data.find((gmpTx) => gmpTx.id.indexOf(txHash) > -1 || gmpTx.call.transactionHash.indexOf(txHash) > -1))
+    .catch(() => undefined);
+const queryTransactionStatus = async (axelarGMPApiUrl, txHash, txLogIndex) => {
+    const txDetails = await fetchGMPTransaction(axelarGMPApiUrl, txHash, txLogIndex);
+    if (!txDetails)
+        return { status: GMPStatus.CANNOT_FETCH_STATUS };
+    const { call, gas_status, gas_paid, executed, express_executed, approved, callback, } = txDetails;
+    const gasPaidInfo = {
+        status: gas_status,
+        details: gas_paid,
+    };
+    // Note: Currently, the GMP API doesn't always return the `total` field in the `time_spent` object
+    // This is a temporary fix to ensure that the `total` field is always present
+    // TODO: Remove this once the API is fixed
+    const timeSpent = txDetails.time_spent;
+    if (timeSpent) {
+        timeSpent.total = timeSpent.total
+            || Object.values(timeSpent).reduce((accumulator, value) => accumulator + value, 0);
+    }
+    return {
+        status: parseGMPStatus(txDetails),
+        error: parseGMPError(txDetails),
+        timeSpent,
+        gasPaidInfo,
+        callTx: call,
+        executed,
+        expressExecuted: express_executed,
+        approved,
+        callback,
+    };
+};
+
+/* eslint-disable no-console */
 /* eslint-disable class-methods-use-this */
 /**
  * Represents a token bridge, which manages asset transfers between two chains.
@@ -30556,6 +30661,7 @@ class TokenBridge {
             to: req.token,
             value: 0,
             from: req.senderAddress,
+            chainId: parseInt(req.sourceChainId, 10),
         };
         return {
             contractToApprove: sourceBridgeAddress,
@@ -30701,6 +30807,7 @@ class TokenBridge {
                     data,
                     to: contractAddress,
                     value: amount.add(fees.bridgeFee).toString(),
+                    chainId: parseInt(sourceChainId, 10),
                 },
             };
         }
@@ -30720,6 +30827,7 @@ class TokenBridge {
                 data,
                 to: contractAddress,
                 value: fees.bridgeFee.toString(),
+                chainId: parseInt(sourceChainId, 10),
             },
         };
     }
@@ -30768,6 +30876,21 @@ class TokenBridge {
             throw new BridgeError(`Childchain provider chainID ${childNetwork.chainId} does not match expected chainID ${this.config.bridgeInstance.childChainID}. ${errMessage}`, BridgeErrorType.UNSUPPORTED_ERROR);
         }
     }
+    getAxelarEndpoint(source) {
+        let axelarAPIEndpoint;
+        if (source === ETH_MAINNET_TO_ZKEVM_MAINNET.rootChainID
+            || source === ETH_MAINNET_TO_ZKEVM_MAINNET.childChainID) {
+            axelarAPIEndpoint = axelarAPIEndpoints.mainnet;
+        }
+        else if (source === ETH_SEPOLIA_TO_ZKEVM_TESTNET.rootChainID
+            || source === ETH_SEPOLIA_TO_ZKEVM_TESTNET.childChainID) {
+            axelarAPIEndpoint = axelarAPIEndpoints.testnet;
+        }
+        else {
+            axelarAPIEndpoint = axelarAPIEndpoints.devnet;
+        }
+        return axelarAPIEndpoint;
+    }
     /**
    * Calculate the gas amount for a transaction using axelarjs-sdk.
    * @param {*} source - The source chainId.
@@ -30786,18 +30909,7 @@ class TokenBridge {
         if (!destinationAxelar) {
             throw new BridgeError(`Destination chainID ${destination} can not be matched to an Axelar chain.`, BridgeErrorType.AXELAR_CHAIN_NOT_FOUND);
         }
-        let axelarApiEndpoint;
-        if (source === ETH_MAINNET_TO_ZKEVM_MAINNET.rootChainID
-            || source === ETH_MAINNET_TO_ZKEVM_MAINNET.childChainID) {
-            axelarApiEndpoint = axelarAPIEndpoints.mainnet;
-        }
-        else if (source === ETH_SEPOLIA_TO_ZKEVM_TESTNET.rootChainID
-            || source === ETH_SEPOLIA_TO_ZKEVM_TESTNET.childChainID) {
-            axelarApiEndpoint = axelarAPIEndpoints.testnet;
-        }
-        else {
-            axelarApiEndpoint = axelarAPIEndpoints.devnet;
-        }
+        const axelarAPIEndpoint = this.getAxelarEndpoint(source);
         let axiosResponse;
         const estimateGasReq = {
             method: 'estimateGasFee',
@@ -30808,7 +30920,7 @@ class TokenBridge {
             gasMultiplier,
         };
         try {
-            axiosResponse = await axios$1.post(axelarApiEndpoint, estimateGasReq);
+            axiosResponse = await axios$1.post(axelarAPIEndpoint, estimateGasReq);
         }
         catch (error) {
             axiosResponse = error.response;
@@ -30825,30 +30937,136 @@ class TokenBridge {
             throw new BridgeError(`Estimating Axelar Gas failed with the reason: ${err}`, BridgeErrorType.AXELAR_GAS_ESTIMATE_FAILED);
         }
     }
-    // STUBBED ENDPOINTS FOR PHASE 2 -------------------------------------------
     /**
    * Queries the status of a bridge transaction.
    *
-   * @param {TokenMappingRequest} req - The request object containing the token, rootChainId and childChainId.
-   * @returns {Promise<TokenMappingResponse>} - A promise that resolves to an object containing the token mappings.
+   * @param {TxStatusRequest} req - The request object containing an array of transactions to query.
+   * @returns {Promise<TxStatusResponse>} - A promise that resolves to an array of transaction statuses.
    * @throws {BridgeError} - If an error occurs during the query, a BridgeError will be thrown with a specific error type.
-   * @dev this SDK method is currently stubbed
    */
     async getTransactionStatus(req) {
-        // eslint-disable-next-line no-console
-        console.log('stubbed response with req', req);
-        // Return the token mappings
-        return {
-            transactions: [{
-                    transactionHash: '0x1234....',
-                    status: StatusResponse.COMPLETE,
-                    data: 'stubbed data',
-                }, {
-                    transactionHash: '0xABCD....',
-                    status: StatusResponse.PROCESSING,
-                    data: 'stubbed data',
-                }],
+        const axelarAPIEndpoint = this.getAxelarEndpoint(req.sourceChainId);
+        const txStatusResponse = {
+            transactions: [],
         };
+        const abiCoder = new AbiCoder();
+        const statusPromises = [];
+        for (const transaction of req.transactions) {
+            statusPromises.push(queryTransactionStatus(axelarAPIEndpoint, transaction.txHash));
+        }
+        let statusResponses;
+        try {
+            statusResponses = await Promise.all(statusPromises);
+        }
+        catch (err) {
+            throw new BridgeError(`Failed to fetch the Axelar Status with the reason: ${err}`, BridgeErrorType.AXELAR_GAS_ESTIMATE_FAILED);
+        }
+        const unpaidGasStatus = [GasPaidStatus.GAS_UNPAID, GasPaidStatus.GAS_PAID_NOT_ENOUGH_GAS];
+        const isWithdraw = [
+            ZKEVM_DEVNET_CHAIN_ID,
+            ZKEVM_TESTNET_CHAIN_ID,
+            ZKEVM_MAINNET_CHAIN_ID
+        ].includes(req.sourceChainId);
+        let rootBridge;
+        if (isWithdraw) {
+            rootBridge = await withBridgeError(async () => {
+                const contract = new Contract(this.config.bridgeContracts.rootERC20BridgeFlowRate, ROOT_ERC20_BRIDGE_FLOW_RATE, this.config.rootProvider);
+                return contract;
+            }, BridgeErrorType.INTERNAL_ERROR);
+        }
+        const flowRatePromises = [];
+        const flowRatePromisesReceivers = [];
+        for (let i = 0, l = statusResponses.length; i < l; i++) {
+            let metaStatus;
+            // consolidate axelar statuses to our own simplified metaStatus
+            switch (statusResponses[i].status) {
+                case GMPStatus.CANNOT_FETCH_STATUS:
+                    metaStatus = StatusResponse.PENDING;
+                    break;
+                case GMPStatus.SRC_GATEWAY_CALLED:
+                case GMPStatus.DEST_GATEWAY_APPROVED:
+                case GMPStatus.DEST_EXECUTING:
+                case GMPStatus.SRC_GATEWAY_CONFIRMED:
+                case GMPStatus.APPROVING:
+                    metaStatus = StatusResponse.PROCESSING;
+                    break;
+                case GMPStatus.NOT_EXECUTED:
+                    metaStatus = StatusResponse.RETRY;
+                    break;
+                case GMPStatus.NOT_EXECUTED_WITHOUT_GAS_PAID:
+                case GMPStatus.INSUFFICIENT_FEE:
+                    metaStatus = StatusResponse.NOT_ENOUGH_GAS;
+                    break;
+                case GMPStatus.DEST_EXECUTED:
+                    metaStatus = StatusResponse.COMPLETE;
+                    break;
+                default:
+                    metaStatus = StatusResponse.ERROR;
+            }
+            if (statusResponses[i].gasPaidInfo) {
+                if (unpaidGasStatus.includes(statusResponses[i].gasPaidInfo.status)) {
+                    metaStatus = StatusResponse.NOT_ENOUGH_GAS;
+                }
+            }
+            let txItem = {
+                txHash: req.transactions[i].txHash,
+                status: metaStatus,
+                data: {
+                    gmpResponse: statusResponses[i].status,
+                },
+            };
+            let decodedData;
+            if (statusResponses[i]?.callTx?.returnValues?.payload) {
+                decodedData = abiCoder.decode(['bytes32', 'address', 'address', 'address', 'uint256'], statusResponses[i].callTx.returnValues.payload);
+                txItem = {
+                    ...txItem,
+                    token: decodedData[1],
+                    sender: decodedData[2],
+                    receiver: decodedData[3],
+                    amount: decodedData[4],
+                };
+            }
+            let flowRatePromiseIndex;
+            if (metaStatus === StatusResponse.COMPLETE
+                && isWithdraw && txItem.receiver) {
+                // consolidate the calls we have to make to the flow rate by receiver
+                if (!flowRatePromisesReceivers.includes(txItem.receiver)) {
+                    flowRatePromises.push(rootBridge.getPendingWithdrawals(txItem.receiver, [0]));
+                    flowRatePromisesReceivers.push(txItem.receiver);
+                    flowRatePromiseIndex = flowRatePromisesReceivers.length - 1;
+                }
+                else {
+                    flowRatePromiseIndex = flowRatePromisesReceivers.findIndex((el) => el === txItem.receiver);
+                }
+                txItem.data.flowRatePromiseIndex = flowRatePromiseIndex;
+            }
+            txStatusResponse.transactions.push(txItem);
+        } // for
+        let flowRateResponses = [];
+        if (flowRatePromises.length > 0) {
+            try {
+                flowRateResponses = await Promise.all(flowRatePromises);
+            }
+            catch (err) {
+                throw new BridgeError(`Failed to fetch the Flow Rate statuses with the reason: ${err}`, BridgeErrorType.FLOW_RATE_ERROR);
+            }
+        }
+        for (const txStatusRes of txStatusResponse.transactions) {
+            if (txStatusRes.data.flowRatePromiseIndex !== -1 && flowRateResponses[txStatusRes.data.flowRatePromiseIndex]) {
+                const flowRatedTx = flowRateResponses[txStatusRes.data.flowRatePromiseIndex].find((el) => (el.amount.toString() === txStatusRes.amount.toString()
+                    && el.token === txStatusRes.token
+                    && el.withdrawer === txStatusRes.sender));
+                if (flowRatedTx) {
+                    txStatusRes.status = StatusResponse.FLOW_RATE_CONTROLLED;
+                    txStatusRes.data = {
+                        timestamp: flowRatedTx.timestamp.toString(),
+                    };
+                }
+            }
+            delete txStatusRes.data.flowRatePromiseIndex;
+        }
+        // Return the tx status response
+        return txStatusResponse;
     }
     /**
    * Queries for the information about which tokens are flowrated and how long the delay is.
@@ -30987,7 +31205,7 @@ const CONTRACTS_FOR_BRIDGE = new Map()
     .set(ETH_SEPOLIA_TO_ZKEVM_TESTNET, {
     rootERC20BridgeFlowRate: '0x0D3C59c779Fd552C27b23F723E80246c840100F5',
     childERC20Bridge: '0x0D3C59c779Fd552C27b23F723E80246c840100F5',
-    wrappedIMX: '0xa86C6C6d3D51c0592BE85dA05A9b06B62360D56E',
+    wrappedIMX: '0x1CcCa691501174B4A623CeDA58cC8f1a76dc3439',
 })
     .set(ETH_MAINNET_TO_ZKEVM_MAINNET, {
     rootERC20BridgeFlowRate: '0x0',
@@ -34698,12 +34916,12 @@ var ChainId;
 })(ChainId || (ChainId = {}));
 /**
  * Enum representing different chain names.
- * @enum {number}
- * @property {number} IMTBL_ZKEVM_MAINNET - The chain name for IMTBL ZKEVM Mainnet.
- * @property {number} IMTBL_ZKEVM_TESTNET - The chain name for IMTBL ZKEVM Testnet.
- * @property {number} IMTBL_ZKEVM_DEVNET - The chain name for IMTBL ZKEVM Devnet.
- * @property {number} ETHEREUM - The chain name for Ethereum.
- * @property {number} SEPOLIA - The chain name for Sepolia.
+ * @enum {string}
+ * @property {string} IMTBL_ZKEVM_MAINNET - The chain name for IMTBL ZKEVM Mainnet.
+ * @property {string} IMTBL_ZKEVM_TESTNET - The chain name for IMTBL ZKEVM Testnet.
+ * @property {string} IMTBL_ZKEVM_DEVNET - The chain name for IMTBL ZKEVM Devnet.
+ * @property {string} ETHEREUM - The chain name for Ethereum.
+ * @property {string} SEPOLIA - The chain name for Sepolia.
  */
 var ChainName;
 (function (ChainName) {
@@ -34713,6 +34931,23 @@ var ChainName;
     ChainName["IMTBL_ZKEVM_DEVNET"] = "Immutable zkEVM Dev";
     ChainName["IMTBL_ZKEVM_MAINNET"] = "Immutable zkEVM";
 })(ChainName || (ChainName = {}));
+/**
+ * Enum representing different chain slugs.
+ * @enum {string}
+ * @property {string} IMTBL_ZKEVM_MAINNET - The chain slug for IMTBL ZKEVM Mainnet.
+ * @property {string} IMTBL_ZKEVM_TESTNET - The chain slug for IMTBL ZKEVM Testnet.
+ * @property {string} IMTBL_ZKEVM_DEVNET - The chain slug for IMTBL ZKEVM Devnet.
+ * @property {string} ETHEREUM - The chain slug for Ethereum.
+ * @property {string} SEPOLIA - The chain slug for Sepolia.
+ */
+var ChainSlug;
+(function (ChainSlug) {
+    ChainSlug["ETHEREUM"] = "ethereum";
+    ChainSlug["SEPOLIA"] = "sepolia";
+    ChainSlug["IMTBL_ZKEVM_MAINNET"] = "imtbl-zkevm-mainnet";
+    ChainSlug["IMTBL_ZKEVM_TESTNET"] = "imtbl-zkevm-testnet";
+    ChainSlug["IMTBL_ZKEVM_DEVNET"] = "imtbl-zkevm-devnet";
+})(ChainSlug || (ChainSlug = {}));
 
 var OnRampProvider;
 (function (OnRampProvider) {
@@ -34877,6 +35112,7 @@ var CheckoutErrorType;
     CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
     CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
     CheckoutErrorType["GET_INDEXER_BALANCE_ERROR"] = "GET_INDEXER_BALANCE_ERROR";
+    CheckoutErrorType["GET_ERC20_INFO_ERROR"] = "GET_ERC20_INFO_ERROR";
     CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_ERROR";
     CheckoutErrorType["GET_ERC721_BALANCE_ERROR"] = "GET_ERC721_BALANCE_ERROR";
     CheckoutErrorType["GET_NETWORK_INFO_ERROR"] = "GET_NETWORK_INFO_ERROR";
@@ -35444,7 +35680,7 @@ const GAS_OVERRIDES = {
     maxPriorityFeePerGas: ethers.BigNumber.from(101e9),
 };
 
-const SDK_VERSION_MARKER = '0.36.3';
+const SDK_VERSION_MARKER = '0.36.5';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -35605,6 +35841,22 @@ const getTokenAllowList = async (config, { type = TokenFilterTypes.ALL, chainId,
     };
 };
 const isNativeToken = (address) => !address || address.toLocaleLowerCase() === NATIVE;
+async function getERC20TokenInfo(web3Provider, tokenAddress) {
+    return await withCheckoutError(async () => {
+        const contract = new ethers.Contract(tokenAddress, JSON.stringify(ERC20ABI), web3Provider);
+        const [name, symbol, decimals] = await Promise.all([
+            contract.name(),
+            contract.symbol(),
+            contract.decimals(),
+        ]);
+        return {
+            name,
+            symbol,
+            decimals,
+            address: tokenAddress,
+        };
+    }, { type: CheckoutErrorType.GET_ERC20_INFO_ERROR });
+}
 
 const CACHE_DATA_TTL = 60; // seconds
 /**
@@ -35775,20 +36027,18 @@ async function getERC20Balance(web3Provider, walletAddress, tokenAddress) {
     return await withCheckoutError(async () => {
         const contract = new ethers.Contract(tokenAddress, JSON.stringify(ERC20ABI), web3Provider);
         return Promise.all([
-            contract.name(),
-            contract.symbol(),
+            getERC20TokenInfo(web3Provider, tokenAddress),
             contract.balanceOf(walletAddress),
-            contract.decimals(),
         ])
-            .then(([name, symbol, balance, decimals]) => {
-            const formattedBalance = ethers.utils.formatUnits(balance, decimals);
+            .then(([tokenInfo, balance]) => {
+            const formattedBalance = ethers.utils.formatUnits(balance, tokenInfo.decimals);
             return {
                 balance,
                 formattedBalance,
                 token: {
-                    name,
-                    symbol,
-                    decimals,
+                    name: tokenInfo.name,
+                    symbol: tokenInfo.symbol,
+                    decimals: tokenInfo.decimals,
                     address: tokenAddress,
                 },
             };
@@ -35888,6 +36138,9 @@ const getBalances = async (config, web3Provider, walletAddress, tokens) => {
     const allBalancePromises = [];
     tokens
         .forEach((token) => {
+        // For some reason isNativeToken always returns undefined.
+        // We have spent way too much time figuring out why this is happening.
+        // That we have given up -- keep it as it is for now.
         if (!token.address || token.address.toLocaleLowerCase() === NATIVE) {
             allBalancePromises.push(getBalance(config, web3Provider, walletAddress));
         }
@@ -35896,13 +36149,25 @@ const getBalances = async (config, web3Provider, walletAddress, tokens) => {
         }
     });
     const balanceResults = await Promise.allSettled(allBalancePromises);
-    const balances = balanceResults.filter((result) => result.status === 'fulfilled').map((result) => result.value);
+    const balances = balanceResults.filter((result) => result.status === 'fulfilled').map((result) => {
+        const resp = result;
+        const { token } = resp.value;
+        // For some reason isNativeToken always returns undefined.
+        // We have spent way too much time figuring out why this is happening.
+        // That we have given up -- keep it as it is for now.
+        if (!token.address || token.address.toLocaleLowerCase() === NATIVE)
+            resp.value.token.address = NATIVE;
+        return resp.value;
+    });
     return { balances };
 };
 const getAllBalances = async (config, web3Provider, walletAddress, chainId) => {
     if (!walletAddress && !web3Provider) {
         throw new CheckoutError('both walletAddress and provider are missing. At least one must be provided.', CheckoutErrorType.MISSING_PARAMS);
     }
+    if (!config.networkMap.get(chainId)) {
+        throw new CheckoutError(`chain ID ${chainId} not supported by the environment`, CheckoutErrorType.CHAIN_NOT_SUPPORTED_ERROR);
+    }
     const { tokens } = await getTokenAllowList(config, {
         type: TokenFilterTypes.ALL,
         chainId,
@@ -37484,11 +37749,11 @@ const getBridgeFeeEstimate = async (config, readOnlyProviders, fromChainId, toCh
 const INDEXER_ETH_ROOT_CONTRACT_ADDRESS = '0x0000000000000000000000000000000000000eee';
 const getIndexerChainName = (chainId) => {
     if (chainId === ChainId.IMTBL_ZKEVM_MAINNET)
-        return 'imtbl-zkevm-mainnet';
+        return ChainSlug.IMTBL_ZKEVM_MAINNET;
     if (chainId === ChainId.IMTBL_ZKEVM_TESTNET)
-        return 'imtbl-zkevm-testnet';
+        return ChainSlug.IMTBL_ZKEVM_TESTNET;
     if (chainId === ChainId.IMTBL_ZKEVM_DEVNET)
-        return 'imtbl-zkevm-devent';
+        return ChainSlug.IMTBL_ZKEVM_DEVNET;
     return '';
 };
 // Indexer ERC20 call does not support IMX so cannot get root chain mapping from this endpoint.
@@ -38934,6 +39199,8 @@ class Checkout {
      */
     async widgets(init) {
         const checkout = this;
+        // Preload the configurations
+        await checkout.config.remote.getConfig();
         const factory = new Promise((resolve, reject) => {
             function checkForWidgetsBundleLoaded() {
                 if (typeof ImmutableCheckoutWidgets !== 'undefined') {
@@ -38949,8 +39216,6 @@ class Checkout {
             try {
                 const script = loadUnresolved(init.version);
                 if (script.loaded && typeof ImmutableCheckoutWidgets !== 'undefined') {
-                    // eslint-disable-next-line no-console
-                    console.warn('Checkout widgets script is already loaded');
                     resolve(new ImmutableCheckoutWidgets.WidgetsFactory(checkout, init.config));
                 }
                 else {
@@ -39004,6 +39269,15 @@ class Checkout {
         const switchNetworkRes = await switchWalletNetwork(this.config, web3Provider, params.chainId);
         return switchNetworkRes;
     }
+    /**
+     * Retrieves the token information given the token address. This function makes RPC calls to
+     * ERC20 contracts to fetch the main contract information (e.g. symbol).
+     * @param {GetTokenInfoParams} params - The parameters for retrieving the token information.
+     * @returns {Promise<TokenInfo>} - A promise that resolves to the token info request.
+     */
+    async getTokenInfo(params) {
+        return await getERC20TokenInfo(params.provider, params.tokenAddress);
+    }
     /**
      * Retrieves the balance of a wallet address.
      * @param {GetBalanceParams} params - The parameters for retrieving the balance.
@@ -39188,6 +39462,7 @@ var checkout = /*#__PURE__*/Object.freeze({
     get BridgeEventType () { return BridgeEventType; },
     get ChainId () { return ChainId; },
     get ChainName () { return ChainName; },
+    get ChainSlug () { return ChainSlug; },
     Checkout: Checkout,
     CheckoutConfiguration: CheckoutConfiguration,
     get CheckoutErrorType () { return CheckoutErrorType; },