@imtbl/sdk 0.36.4 → 0.36.5

package/dist/checkout.d.ts

@@ -11618,10 +11618,10 @@ type ImxAddressConfig = {
 };
 /**
  * A type representing the telemetry configurations.
- * @property {string} publishableApiKey
+ * @property {string} segmentPublishableKey
  */
 type TelemetryConfig = {
-    publishableApiKey: string;
+    segmentPublishableKey: string;
 };
 /**
  * A type representing the required information to estimate gas for a transaction.

package/dist/checkout.js

@@ -3234,105 +3234,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) {
@@ -12519,6 +12420,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: [
@@ -14779,6 +14779,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.
@@ -16091,16 +16092,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";
@@ -16109,6 +16111,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.
@@ -16300,6 +16405,7 @@ class TokenBridge {
             to: req.token,
             value: 0,
             from: req.senderAddress,
+            chainId: parseInt(req.sourceChainId, 10),
         };
         return {
             contractToApprove: sourceBridgeAddress,
@@ -16445,6 +16551,7 @@ class TokenBridge {
                     data,
                     to: contractAddress,
                     value: amount.add(fees.bridgeFee).toString(),
+                    chainId: parseInt(sourceChainId, 10),
                 },
             };
         }
@@ -16464,6 +16571,7 @@ class TokenBridge {
                 data,
                 to: contractAddress,
                 value: fees.bridgeFee.toString(),
+                chainId: parseInt(sourceChainId, 10),
             },
         };
     }
@@ -16512,6 +16620,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.
@@ -16530,18 +16653,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',
@@ -16552,7 +16664,7 @@ class TokenBridge {
             gasMultiplier,
         };
         try {
-            axiosResponse = await axios$1.post(axelarApiEndpoint, estimateGasReq);
+            axiosResponse = await axios$1.post(axelarAPIEndpoint, estimateGasReq);
         }
         catch (error) {
             axiosResponse = error.response;
@@ -16569,30 +16681,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.
@@ -16731,7 +16949,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',
@@ -25833,7 +26051,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.36.4',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.36.5',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -27157,7 +27375,7 @@ const GAS_OVERRIDES = {
     maxPriorityFeePerGas: BigNumber$1.from(101e9),
 };
 
-const SDK_VERSION_MARKER = '0.36.4';
+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;
 

package/dist/immutablex_client.js

@@ -17,7 +17,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.36.4',
+    sdkVersion: 'ts-immutable-sdk-0.36.5',
 });
 /**
  * Sets `sdkVersion` at the time of build