@imtbl/sdk 0.36.4 → 0.37.0

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.4' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.37.0' };
 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.4',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.37.0',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4755,7 +4755,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.36.4',
+    sdkVersion: 'ts-immutable-sdk-0.37.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -12254,13 +12254,13 @@ var ProtocolData;
     })(ProtocolData.order_type || (ProtocolData.order_type = {}));
 })(ProtocolData || (ProtocolData = {}));
 
-var FeeType;
+var FeeType$1;
 (function (FeeType) {
     FeeType["MAKER_ECOSYSTEM"] = "MAKER_ECOSYSTEM";
     FeeType["TAKER_ECOSYSTEM"] = "TAKER_ECOSYSTEM";
     FeeType["PROTOCOL"] = "PROTOCOL";
     FeeType["ROYALTY"] = "ROYALTY";
-})(FeeType || (FeeType = {}));
+})(FeeType$1 || (FeeType$1 = {}));
 var TransactionPurpose;
 (function (TransactionPurpose) {
     TransactionPurpose["APPROVAL"] = "APPROVAL";
@@ -12822,7 +12822,7 @@ class ImmutableApiClient {
                 ],
                 fees: makerFees.map((x) => ({
                     amount: x.amount,
-                    type: FeeType.MAKER_ECOSYSTEM,
+                    type: FeeType$1.MAKER_ECOSYSTEM,
                     recipient_address: x.recipientAddress,
                 })),
                 end_at: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
@@ -13036,7 +13036,7 @@ class Orderbook {
                 order_id: listingId,
                 fees: takerFees.map((fee) => ({
                     amount: fee.amount,
-                    type: FeeType.TAKER_ECOSYSTEM,
+                    type: FeeType$1.TAKER_ECOSYSTEM,
                     recipient_address: fee.recipientAddress,
                 })),
             },
@@ -13059,7 +13059,7 @@ class Orderbook {
             order_id: listingRequest.listingId,
             fees: listingRequest.takerFees.map((fee) => ({
                 amount: fee.amount,
-                type: FeeType.TAKER_ECOSYSTEM,
+                type: FeeType$1.TAKER_ECOSYSTEM,
                 recipient_address: fee.recipientAddress,
             })),
         })));
@@ -13190,7 +13190,7 @@ const constants = {
 var orderbook = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get ActionType () { return ActionType; },
-    get FeeType () { return FeeType; },
+    get FeeType () { return FeeType$1; },
     get OrderStatusName () { return OrderStatusName; },
     Orderbook: Orderbook,
     get SignablePurpose () { return SignablePurpose; },
@@ -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',
@@ -34857,6 +35075,21 @@ var RoutingOutcomeType;
     RoutingOutcomeType["NO_ROUTES_FOUND"] = "NO_ROUTES_FOUND";
     RoutingOutcomeType["NO_ROUTE_OPTIONS"] = "NO_ROUTE_OPTIONS";
 })(RoutingOutcomeType || (RoutingOutcomeType = {}));
+/**
+ * An enum representing the funding step types
+ * @enum {string}
+ * @property {string} GAS - If the fee is a gas fee.
+ * @property {string} BRIDGE_FEE - If the fee is a bridge fee.
+ * @property {string} SWAP_FEE - If the fee is a swap fee.
+ * @property {string} IMMUTABLE_FEE - If the fee is an immutable fee.
+ */
+var FeeType;
+(function (FeeType) {
+    FeeType["GAS"] = "GAS";
+    FeeType["BRIDGE_FEE"] = "BRIDGE_FEE";
+    FeeType["SWAP_FEE"] = "SWAP_FEE";
+    FeeType["IMMUTABLE_FEE"] = "IMMUTABLE_FEE";
+})(FeeType || (FeeType = {}));
 /**
  * An enum representing the funding step types
  * @enum {string}
@@ -35462,7 +35695,7 @@ const GAS_OVERRIDES = {
     maxPriorityFeePerGas: ethers.BigNumber.from(101e9),
 };
 
-const SDK_VERSION_MARKER = '0.36.4';
+const SDK_VERSION_MARKER = '0.37.0';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -36356,8 +36589,8 @@ const erc20ItemAggregator = (itemRequirements) => {
             aggregatedItemRequirements.push(itemRequirement);
             return;
         }
-        const { contractAddress, spenderAddress, amount } = itemRequirement;
-        const key = `${contractAddress}${spenderAddress}`;
+        const { tokenAddress, spenderAddress, amount } = itemRequirement;
+        const key = `${tokenAddress}${spenderAddress}`;
         const aggregateItem = aggregatedMap.get(key);
         if (aggregateItem && aggregateItem.type === ItemType.ERC20) {
             aggregateItem.amount = ethers.BigNumber.from(aggregateItem.amount).add(amount);
@@ -36423,10 +36656,10 @@ const hasERC20Allowances = async (provider, ownerAddress, itemRequirements) => {
     for (const itemRequirement of itemRequirements) {
         if (itemRequirement.type !== ItemType.ERC20)
             continue;
-        const { contractAddress, spenderAddress } = itemRequirement;
-        const key = `${contractAddress}${spenderAddress}`;
+        const { tokenAddress, spenderAddress } = itemRequirement;
+        const key = `${tokenAddress}${spenderAddress}`;
         erc20s.set(key, itemRequirement);
-        allowancePromises.set(key, getERC20Allowance(provider, ownerAddress, contractAddress, spenderAddress));
+        allowancePromises.set(key, getERC20Allowance(provider, ownerAddress, tokenAddress, spenderAddress));
     }
     const allowances = await Promise.all(allowancePromises.values());
     const allowancePromiseIds = Array.from(allowancePromises.keys());
@@ -36445,8 +36678,8 @@ const hasERC20Allowances = async (provider, ownerAddress, itemRequirements) => {
             continue;
         }
         sufficient = false; // Set sufficient false on the root of the return object when an ERC20 is insufficient
-        const { contractAddress, spenderAddress } = itemRequirement;
-        const key = `${contractAddress}${spenderAddress}`;
+        const { tokenAddress, spenderAddress } = itemRequirement;
+        const key = `${tokenAddress}${spenderAddress}`;
         const delta = itemRequirement.amount.sub(allowances[index]);
         // Create maps for both the insufficient ERC20 data and the transaction promises using the same key so the results can be merged
         insufficientERC20s.set(key, {
@@ -36456,7 +36689,7 @@ const hasERC20Allowances = async (provider, ownerAddress, itemRequirements) => {
             itemRequirement,
             approvalTransaction: undefined,
         });
-        transactionPromises.set(key, getERC20ApprovalTransaction(provider, ownerAddress, contractAddress, spenderAddress, delta));
+        transactionPromises.set(key, getERC20ApprovalTransaction(provider, ownerAddress, tokenAddress, spenderAddress, delta));
     }
     // Resolves the approval transactions and merges them with the insufficient ERC20 data
     const transactions = await Promise.all(transactionPromises.values());
@@ -36641,8 +36874,8 @@ const erc20BalanceAggregator = (itemRequirements) => {
             aggregatedItemRequirements.push(itemRequirement);
             return;
         }
-        const { contractAddress, amount } = itemRequirement;
-        const key = `${contractAddress}`;
+        const { tokenAddress, amount } = itemRequirement;
+        const key = `${tokenAddress}`;
         const aggregateItem = aggregatedMap.get(key);
         if (aggregateItem && aggregateItem.type === ItemType.ERC20) {
             aggregateItem.amount = ethers.BigNumber.from(aggregateItem.amount).add(amount);
@@ -36675,14 +36908,21 @@ const balanceAggregator = (itemRequirements) => erc721BalanceAggregator(erc20Bal
 /* eslint-disable arrow-body-style */
 const getTokensFromRequirements = (itemRequirements) => itemRequirements
     .map((itemRequirement) => {
-    if (itemRequirement.type === ItemType.NATIVE) {
-        return {
-            address: NATIVE,
-        };
+    switch (itemRequirement.type) {
+        case ItemType.ERC20:
+            return {
+                address: itemRequirement.tokenAddress,
+            };
+        case ItemType.NATIVE:
+            return {
+                address: NATIVE,
+            };
+        case ItemType.ERC721:
+        default:
+            return {
+                address: itemRequirement.contractAddress,
+            };
     }
-    return {
-        address: itemRequirement.contractAddress,
-    };
 });
 /**
  * Gets the balance requirement with delta for an ERC721 requirement.
@@ -36732,7 +36972,7 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
     // Get the requirements related balance
     if (itemRequirement.type === ItemType.ERC20) {
         itemBalanceResult = balances.find((balance) => {
-            return balance.token?.address === itemRequirement.contractAddress;
+            return balance.token?.address === itemRequirement.tokenAddress;
         });
     }
     else if (itemRequirement.type === ItemType.NATIVE) {
@@ -36796,7 +37036,7 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
             token: {
                 name,
                 symbol,
-                address: itemRequirement.contractAddress,
+                address: itemRequirement.tokenAddress,
                 decimals,
             },
         };
@@ -36955,7 +37195,7 @@ const getGasItemRequirement = (gas, transactionOrGas) => {
     return {
         type: ItemType.ERC20,
         amount: gas,
-        contractAddress: transactionOrGas.gasToken.contractAddress,
+        tokenAddress: transactionOrGas.gasToken.tokenAddress,
         spenderAddress: '',
     };
 };
@@ -37178,36 +37418,37 @@ const quoteFetcher = async (config, chainId, walletAddress, requiredToken, swapp
     }
 };
 
-const constructFees$1 = (approvalGasFees, swapGasFees, swapFees) => {
+const constructFees$1 = (approvalGasFee, swapGasFee, swapFees) => {
     let approvalGasFeeAmount = ethers.BigNumber.from(0);
     let approvalGasFeeFormatted = '0';
     let approvalToken;
-    if (approvalGasFees) {
-        approvalGasFeeAmount = approvalGasFees.value;
-        approvalGasFeeFormatted = ethers.utils.formatUnits(approvalGasFees.value, approvalGasFees.token.decimals);
+    if (approvalGasFee) {
+        approvalGasFeeAmount = approvalGasFee.value;
+        approvalGasFeeFormatted = ethers.utils.formatUnits(approvalGasFee.value, approvalGasFee.token.decimals);
         approvalToken = {
-            name: approvalGasFees.token.name ?? '',
-            symbol: approvalGasFees.token.symbol ?? '',
-            address: approvalGasFees.token.address,
-            decimals: approvalGasFees.token.decimals,
+            name: approvalGasFee.token.name ?? '',
+            symbol: approvalGasFee.token.symbol ?? '',
+            address: approvalGasFee.token.address,
+            decimals: approvalGasFee.token.decimals,
         };
     }
     let swapGasFeeAmount = ethers.BigNumber.from(0);
     let swapGasFeeFormatted = '0';
     let swapGasToken;
-    if (swapGasFees) {
-        swapGasFeeAmount = swapGasFees.value;
-        swapGasFeeFormatted = ethers.utils.formatUnits(swapGasFees.value, swapGasFees.token.decimals);
+    if (swapGasFee) {
+        swapGasFeeAmount = swapGasFee.value;
+        swapGasFeeFormatted = ethers.utils.formatUnits(swapGasFee.value, swapGasFee.token.decimals);
         swapGasToken = {
-            name: swapGasFees.token.name ?? '',
-            symbol: swapGasFees.token.symbol ?? '',
-            address: swapGasFees.token.address,
-            decimals: swapGasFees.token.decimals,
+            name: swapGasFee.token.name ?? '',
+            symbol: swapGasFee.token.symbol ?? '',
+            address: swapGasFee.token.address,
+            decimals: swapGasFee.token.decimals,
         };
     }
     const fees = [];
     for (const swapFee of swapFees) {
         fees.push({
+            type: FeeType.SWAP_FEE,
             amount: swapFee.amount.value,
             formattedAmount: ethers.utils.formatUnits(swapFee.amount.value, swapFee.amount.token.decimals),
             token: {
@@ -37219,12 +37460,14 @@ const constructFees$1 = (approvalGasFees, swapGasFees, swapFees) => {
         });
     }
     return {
-        approvalGasFees: {
+        approvalGasFee: {
+            type: FeeType.GAS,
             amount: approvalGasFeeAmount,
             formattedAmount: approvalGasFeeFormatted,
             token: approvalToken,
         },
-        swapGasFees: {
+        swapGasFee: {
+            type: FeeType.GAS,
             amount: swapGasFeeAmount,
             formattedAmount: swapGasFeeFormatted,
             token: swapGasToken,
@@ -37309,7 +37552,7 @@ const checkUserCanCoverApprovalFees = (l2Balances, approval) => {
     // The user has enough to cover approval gas fees
     return { sufficient: true, approvalGasFee, approvalGasTokenAddress };
 };
-const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFees, swapFees, tokenBeingSwapped) => {
+const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFee, swapFees, tokenBeingSwapped) => {
     // Set up a map of token addresses to amounts for each of the swap fees
     const feeMap = new Map();
     // Add the approval fee to list of fees
@@ -37317,13 +37560,13 @@ const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFees, swapFe
         feeMap.set(approvalFees.approvalGasTokenAddress, approvalFees.approvalGasFee);
     }
     // Add the swap gas fee to list of fees
-    if (swapGasFees) {
-        const fee = feeMap.get(swapGasFees.token.address);
+    if (swapGasFee) {
+        const fee = feeMap.get(swapGasFee.token.address);
         if (fee) {
-            feeMap.set(swapGasFees.token.address, fee.add(swapGasFees.value));
+            feeMap.set(swapGasFee.token.address, fee.add(swapGasFee.value));
         }
         else {
-            feeMap.set(swapGasFees.token.address, swapGasFees.value);
+            feeMap.set(swapGasFee.token.address, swapGasFee.value);
         }
     }
     // Add the token being swapped to list of fees to ensure the user can cover the fee + the token swap
@@ -37577,31 +37820,39 @@ const hasSufficientL1Eth = (tokenBalanceResult, totalFees) => {
     const balance = getEthBalance(tokenBalanceResult);
     return balance.gte(totalFees);
 };
-const constructFees = (bridgeGasFees, bridgeFee, imtblFee, approvalGasFees, token) => {
+const constructFees = (bridgeGasFee, bridgeFee, imtblFee, approvalGasFee, token) => {
     const bridgeFeeDecimals = token?.decimals ?? DEFAULT_TOKEN_DECIMALS$1;
+    const bridgeFees = [];
+    if (bridgeFee.gt(0)) {
+        bridgeFees.push({
+            type: FeeType.BRIDGE_FEE,
+            amount: bridgeFee,
+            formattedAmount: ethers.utils.formatUnits(bridgeFee, bridgeFeeDecimals),
+            token,
+        });
+    }
+    if (imtblFee.gt(0)) {
+        bridgeFees.push({
+            type: FeeType.IMMUTABLE_FEE,
+            amount: imtblFee,
+            formattedAmount: ethers.utils.formatUnits(imtblFee, bridgeFeeDecimals),
+            token,
+        });
+    }
     return {
-        approvalGasFees: {
-            amount: approvalGasFees,
-            formattedAmount: ethers.utils.formatUnits(approvalGasFees, DEFAULT_TOKEN_DECIMALS$1),
+        approvalGasFee: {
+            type: FeeType.GAS,
+            amount: approvalGasFee,
+            formattedAmount: ethers.utils.formatUnits(approvalGasFee, DEFAULT_TOKEN_DECIMALS$1),
             token,
         },
-        bridgeGasFees: {
-            amount: bridgeGasFees,
-            formattedAmount: ethers.utils.formatUnits(bridgeGasFees, DEFAULT_TOKEN_DECIMALS$1),
+        bridgeGasFee: {
+            type: FeeType.GAS,
+            amount: bridgeGasFee,
+            formattedAmount: ethers.utils.formatUnits(bridgeGasFee, DEFAULT_TOKEN_DECIMALS$1),
             token,
         },
-        bridgeFees: [
-            {
-                amount: bridgeFee,
-                formattedAmount: ethers.utils.formatUnits(bridgeFee, bridgeFeeDecimals),
-                token,
-            },
-            {
-                amount: imtblFee,
-                formattedAmount: ethers.utils.formatUnits(imtblFee, bridgeFeeDecimals),
-                token,
-            },
-        ],
+        bridgeFees,
     };
 };
 const constructBridgeFundingRoute = (chainId, balance, bridgeRequirement, itemType, fees) => ({
@@ -38460,13 +38711,13 @@ const calculateFees = (orderFees, weiAmount, decimals = 18) => {
     return calculateFeesResult;
 };
 
-const getItemRequirement = (type, contractAddress, amount, spenderAddress) => {
+const getItemRequirement = (type, tokenAddress, amount, spenderAddress) => {
     switch (type) {
         case ItemType.ERC20:
             return {
                 type,
                 amount,
-                contractAddress,
+                tokenAddress,
                 spenderAddress,
             };
         case ItemType.NATIVE:
@@ -38689,7 +38940,7 @@ const getBuyToken = (buyToken, decimals = 18) => {
     return {
         type: ItemType.ERC20,
         amount: bnAmount.toString(),
-        contractAddress: buyToken.contractAddress,
+        contractAddress: buyToken.tokenAddress,
     };
 };
 const sell = async (config, provider, orders) => {
@@ -38703,7 +38954,7 @@ const sell = async (config, provider, orders) => {
     let decimals = 18;
     if (buyToken.type === ItemType.ERC20) {
         // get this from the allowed list
-        const buyTokenContract = new ethers.Contract(buyToken.contractAddress, JSON.stringify(ERC20ABI), provider);
+        const buyTokenContract = new ethers.Contract(buyToken.tokenAddress, JSON.stringify(ERC20ABI), provider);
         decimals = await measureAsyncExecution(config, 'Time to get decimals of token contract for the buy token', buyTokenContract.decimals());
     }
     const buyTokenOrNative = getBuyToken(buyToken, decimals);
@@ -38855,8 +39106,8 @@ async function getItemRequirementsFromRequirements(provider, requirements) {
     const decimalPromises = [];
     requirements.forEach((itemRequirementParam) => {
         if (itemRequirementParam.type === ItemType.ERC20) {
-            const { contractAddress } = itemRequirementParam;
-            decimalPromises.push(getTokenContract(contractAddress, ERC20ABI, provider).decimals());
+            const { tokenAddress } = itemRequirementParam;
+            decimalPromises.push(getTokenContract(tokenAddress, ERC20ABI, provider).decimals());
         }
     });
     const decimals = await Promise.all(decimalPromises);
@@ -39171,7 +39422,7 @@ class Checkout {
         try {
             itemRequirements = await getItemRequirementsFromRequirements(web3Provider, params.itemRequirements);
         }
-        catch {
+        catch (error) {
             throw new CheckoutError('Failed to map item requirements', CheckoutErrorType.ITEM_REQUIREMENTS_ERROR);
         }
         return await smartCheckout(this.config, web3Provider, itemRequirements, params.transactionOrGasAmount);
@@ -39252,6 +39503,7 @@ var checkout = /*#__PURE__*/Object.freeze({
     get ConnectEventType () { return ConnectEventType; },
     get ConnectTargetLayer () { return ConnectTargetLayer; },
     get ExchangeType () { return ExchangeType; },
+    get FeeType () { return FeeType; },
     get FundingStepType () { return FundingStepType; },
     get GasEstimateType () { return GasEstimateType; },
     get GasTokenType () { return GasTokenType; },