@imtbl/sdk 0.31.3 → 0.33.0

package/dist/{checkout_sdk.js → checkout.js}

@@ -14832,13 +14832,13 @@ const subtractAmount = (a, b) => {
 /**
  * Converts our internal token type which could be ERC20 or Native
  * into a format consumable by Checkout. They require an address to be
- * present. We populate the address with empty string if it's Native.
+ * present. We populate the address with the string 'native' if it's Native.
  * If it's ERC20, we don't need to change it.
  */
 const toPublicTokenType = (token) => {
     if (token.type === 'native') {
         return {
-            address: '',
+            address: 'native',
             chainId: token.chainId,
             decimals: token.decimals,
             symbol: token.symbol,
@@ -15150,7 +15150,7 @@ const doesChainSupportEIP1559$1 = (fee) => {
 /**
  * Fetch the current gas price estimate. Supports both EIP-1559 and non-EIP1559 chains
  * @param {JsonRpcProvider} provider - The JSON RPC provider used to fetch fee data
- * @param {Coin} nativeToken - The native token of the chain. Gas prices will be denominated in this token
+ * @param {Native} nativeToken - The native token of the chain. Gas prices will be denominated in this token
  * @returns {Amount | null} - The gas price in the smallest denomination of the chain's currency,
  *  or null if no gas price is available
  */
@@ -15275,9 +15275,6 @@ class NativeTokenService {
         this.wrappedToken = wrappedToken;
     }
     wrapAmount(amount) {
-        if (!canUnwrapToken(amount.token)) {
-            throw new Error(`cannot wrap non-native token: ${amount.token.address}`);
-        }
         return newAmount(amount.value, this.wrappedToken);
     }
     unwrapAmount(amount) {
@@ -20987,7 +20984,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.31.3',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.33.0',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -21600,412 +21597,73 @@ const validateProviderDefaults = {
     allowUnsupportedProvider: false,
 };
 
-const ENV_DEVELOPMENT = 'development';
-const IMX_ADDRESS_ZKEVM = '0x0000000000000000000000000000000000001010';
-const DEFAULT_TOKEN_DECIMALS$1 = 18;
-const ZKEVM_NATIVE_TOKEN = {
-    name: 'IMX',
-    symbol: 'IMX',
-    decimals: DEFAULT_TOKEN_DECIMALS$1,
-    address: IMX_ADDRESS_ZKEVM,
-};
 /**
- * Base URL for the Immutable API based on the environment.
- * @property {string} DEVELOPMENT - The base URL for the development environment.
- * @property {string} SANDBOX - The base URL for the sandbox environment.
- * @property {string} PRODUCTION - The base URL for the production environment.
+ * An enum representing the checkout status types
+ * @enum {string}
+ * @property {string} SUCCESS - If checkout succeeded as the transactions were able to be processed
+ * @property {string} FAILED - If checkout failed due to transactions not settling on chain
+ * @property {string} INSUFFICIENT_FUNDS - If checkout failed due to insufficient funds
  */
-const IMMUTABLE_API_BASE_URL = {
-    [ENV_DEVELOPMENT]: 'https://api.dev.immutable.com',
-    [Environment$1.SANDBOX]: 'https://api.sandbox.immutable.com',
-    [Environment$1.PRODUCTION]: 'https://api.immutable.com',
-};
+var CheckoutStatus;
+(function (CheckoutStatus) {
+    CheckoutStatus["SUCCESS"] = "SUCCESS";
+    CheckoutStatus["FAILED"] = "FAILED";
+    CheckoutStatus["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+})(CheckoutStatus || (CheckoutStatus = {}));
 /**
- * Base URL for the checkout API based on the environment.
- * @property {string} DEVELOPMENT - The base URL for the development environment.
- * @property {string} SANDBOX - The base URL for the sandbox environment.
- * @property {string} PRODUCTION - The base URL for the production environment.
+ * An enum representing the item types
+ * @enum {string}
+ * @property {string} NATIVE - If the item is a native token.
+ * @property {string} ERC20 - If the item is an ERC20 token.
+ * @property {string} ERC721 - If the item is an ERC721 token.
  */
-const CHECKOUT_API_BASE_URL = {
-    [ENV_DEVELOPMENT]: 'https://checkout-api.dev.immutable.com',
-    [Environment$1.SANDBOX]: 'https://checkout-api.sandbox.immutable.com',
-    [Environment$1.PRODUCTION]: 'https://checkout-api.immutable.com',
-};
+var ItemType;
+(function (ItemType) {
+    ItemType["NATIVE"] = "NATIVE";
+    ItemType["ERC20"] = "ERC20";
+    ItemType["ERC721"] = "ERC721";
+})(ItemType || (ItemType = {}));
 /**
- * Smart Checkout routing default onramp enabled flag
+ * An enum representing transaction or gas types
+ * @enum {string}
+ * @property {string} TRANSACTION - If the type is a transaction
+ * @property {string} GAS - If the type is the gas amount
  */
-const DEFAULT_ON_RAMP_ENABLED = true;
+var TransactionOrGasType;
+(function (TransactionOrGasType) {
+    TransactionOrGasType["TRANSACTION"] = "TRANSACTION";
+    TransactionOrGasType["GAS"] = "GAS";
+})(TransactionOrGasType || (TransactionOrGasType = {}));
 /**
- * Smart Checkout routing default swap enabled flag
+ * An enum representing the gas token types
+ * @enum {string}
+ * @property {string} NATIVE - If the gas token is a native token.
+ * @property {string} ERC20 - If the gas token is an ERC20 token.
  */
-const DEFAULT_SWAP_ENABLED = true;
+var GasTokenType;
+(function (GasTokenType) {
+    GasTokenType["NATIVE"] = "NATIVE";
+    GasTokenType["ERC20"] = "ERC20";
+})(GasTokenType || (GasTokenType = {}));
 /**
- * Smart Checkout routing default bridge enabled flag
+ * An enum representing the routing outcome types
+ * @enum {string}
+ * @property {string} ROUTES_FOUND - If funding routes were found for the transaction.
+ * @property {string} NO_ROUTES_FOUND - If no funding routes were found for the transaction.
+ * @property {string} NO_ROUTE_OPTIONS - If no routing options were available for the transaction.
  */
-const DEFAULT_BRIDGE_ENABLED = true;
-const TRANSAK_API_BASE_URL = {
-    [Environment$1.SANDBOX]: 'https://global-stg.transak.com',
-    [Environment$1.PRODUCTION]: 'https://global.transak.com/',
-};
-const PRODUCTION_CHAIN_ID_NETWORK_MAP = new Map([
-    [
-        ChainId.ETHEREUM,
-        {
-            chainIdHex: `0x${ChainId.ETHEREUM.toString(16)}`,
-            chainName: ChainName.ETHEREUM,
-            rpcUrls: ['https://checkout-api.immutable.com/v1/rpc/eth-mainnet'],
-            nativeCurrency: {
-                name: ChainName.ETHEREUM,
-                symbol: 'ETH',
-                decimals: 18,
-            },
-            blockExplorerUrls: ['https://etherscan.io/'],
-        },
-    ],
-    [
-        ChainId.IMTBL_ZKEVM_MAINNET,
-        {
-            chainIdHex: `0x${ChainId.IMTBL_ZKEVM_MAINNET.toString(16)}`,
-            chainName: ChainName.IMTBL_ZKEVM_MAINNET,
-            rpcUrls: ['https://rpc.immutable.com'],
-            nativeCurrency: ZKEVM_NATIVE_TOKEN,
-        },
-    ],
-]);
-const SANDBOX_CHAIN_ID_NETWORK_MAP = new Map([
-    [
-        ChainId.SEPOLIA,
-        {
-            chainIdHex: `0x${ChainId.SEPOLIA.toString(16)}`,
-            chainName: ChainName.SEPOLIA,
-            rpcUrls: [
-                'https://checkout-api.sandbox.immutable.com/v1/rpc/eth-sepolia',
-            ],
-            nativeCurrency: {
-                name: 'Sep Eth',
-                symbol: 'ETH',
-                decimals: 18,
-            },
-            blockExplorerUrls: ['https://sepolia.etherscan.io/'],
-        },
-    ],
-    [
-        ChainId.IMTBL_ZKEVM_TESTNET,
-        {
-            chainIdHex: `0x${ChainId.IMTBL_ZKEVM_TESTNET.toString(16)}`,
-            chainName: ChainName.IMTBL_ZKEVM_TESTNET,
-            rpcUrls: ['https://rpc.testnet.immutable.com'],
-            nativeCurrency: ZKEVM_NATIVE_TOKEN,
-        },
-    ],
-]);
-const DEV_CHAIN_ID_NETWORK_MAP = new Map([
-    [
-        ChainId.SEPOLIA,
-        {
-            chainIdHex: `0x${ChainId.SEPOLIA.toString(16)}`,
-            chainName: ChainName.SEPOLIA,
-            rpcUrls: ['https://checkout-api.dev.immutable.com/v1/rpc/eth-sepolia'],
-            nativeCurrency: {
-                name: 'Sep Eth',
-                symbol: 'ETH',
-                decimals: 18,
-            },
-            blockExplorerUrls: ['https://sepolia.etherscan.io/'],
-        },
-    ],
-    [
-        ChainId.IMTBL_ZKEVM_DEVNET,
-        {
-            chainIdHex: `0x${ChainId.IMTBL_ZKEVM_DEVNET.toString(16)}`,
-            chainName: ChainName.IMTBL_ZKEVM_DEVNET,
-            rpcUrls: ['https://rpc.dev.immutable.com'],
-            nativeCurrency: ZKEVM_NATIVE_TOKEN,
-        },
-    ],
-]);
+var RoutingOutcomeType;
+(function (RoutingOutcomeType) {
+    RoutingOutcomeType["ROUTES_FOUND"] = "ROUTES_FOUND";
+    RoutingOutcomeType["NO_ROUTES_FOUND"] = "NO_ROUTES_FOUND";
+    RoutingOutcomeType["NO_ROUTE_OPTIONS"] = "NO_ROUTE_OPTIONS";
+})(RoutingOutcomeType || (RoutingOutcomeType = {}));
 /**
- * Blockscout API configuration per chain
- */
-const BLOCKSCOUT_CHAIN_URL_MAP = {
-    [ChainId.IMTBL_ZKEVM_TESTNET]: {
-        url: 'https://explorer.testnet.immutable.com',
-        nativeToken: SANDBOX_CHAIN_ID_NETWORK_MAP.get(ChainId.IMTBL_ZKEVM_TESTNET).nativeCurrency,
-    },
-    [ChainId.IMTBL_ZKEVM_MAINNET]: {
-        url: 'https://explorer.mainnet.immutable.com',
-        nativeToken: PRODUCTION_CHAIN_ID_NETWORK_MAP.get(ChainId.IMTBL_ZKEVM_MAINNET).nativeCurrency,
-    },
-    [ChainId.SEPOLIA]: {
-        url: 'https://eth-sepolia.blockscout.com',
-        nativeToken: SANDBOX_CHAIN_ID_NETWORK_MAP.get(ChainId.SEPOLIA).nativeCurrency,
-    },
-    [ChainId.ETHEREUM]: {
-        url: 'https://eth.blockscout.com/',
-        nativeToken: PRODUCTION_CHAIN_ID_NETWORK_MAP.get(ChainId.ETHEREUM).nativeCurrency,
-    },
-};
-const ERC20ABI = [
-    {
-        constant: true,
-        inputs: [],
-        name: 'name',
-        outputs: [
-            {
-                name: '',
-                type: 'string',
-            },
-        ],
-        payable: false,
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [],
-        name: 'decimals',
-        outputs: [
-            {
-                name: '',
-                type: 'uint8',
-            },
-        ],
-        payable: false,
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [
-            {
-                name: '_owner',
-                type: 'address',
-            },
-        ],
-        name: 'balanceOf',
-        outputs: [
-            {
-                name: 'balance',
-                type: 'uint256',
-            },
-        ],
-        payable: false,
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [],
-        name: 'symbol',
-        outputs: [
-            {
-                name: '',
-                type: 'string',
-            },
-        ],
-        payable: false,
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [
-            {
-                name: '_owner',
-                type: 'address',
-            },
-            {
-                name: '_spender',
-                type: 'address',
-            },
-        ],
-        name: 'allowance',
-        outputs: [
-            {
-                name: '',
-                type: 'uint256',
-            },
-        ],
-        payable: false,
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        constant: false,
-        inputs: [
-            {
-                name: '_spender',
-                type: 'address',
-            },
-            {
-                name: '_value',
-                type: 'uint256',
-            },
-        ],
-        name: 'approve',
-        outputs: [
-            {
-                name: '',
-                type: 'bool',
-            },
-        ],
-        payable: false,
-        stateMutability: 'nonpayable',
-        type: 'function',
-    },
-];
-const ERC721ABI = [
-    {
-        constant: false,
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'to',
-                type: 'address',
-            },
-            {
-                internalType: 'uint256',
-                name: 'tokenId',
-                type: 'uint256',
-            },
-        ],
-        name: 'approve',
-        outputs: [],
-        payable: false,
-        stateMutability: 'nonpayable',
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [
-            {
-                internalType: 'address',
-                name: 'owner',
-                type: 'address',
-            },
-            {
-                internalType: 'address',
-                name: 'operator',
-                type: 'address',
-            },
-        ],
-        name: 'isApprovedForAll',
-        outputs: [
-            {
-                internalType: 'bool',
-                name: '',
-                type: 'bool',
-            },
-        ],
-        payable: false,
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        constant: true,
-        inputs: [
-            {
-                internalType: 'uint256',
-                name: 'tokenId',
-                type: 'uint256',
-            },
-        ],
-        name: 'getApproved',
-        outputs: [
-            {
-                internalType: 'address',
-                name: '',
-                type: 'address',
-            },
-        ],
-        payable: false,
-        stateMutability: 'view',
-        type: 'function',
-    },
-    {
-        inputs: [
-            {
-                internalType: 'uint256',
-                name: 'tokenId',
-                type: 'uint256',
-            },
-        ],
-        name: 'ownerOf',
-        outputs: [
-            {
-                internalType: 'address',
-                name: '',
-                type: 'address',
-            },
-        ],
-        stateMutability: 'view',
-        type: 'function',
-    },
-];
-
-/**
- * An enum representing the checkout status types
- * @enum {string}
- * @property {string} SUCCESS - If checkout succeeded as the transactions were able to be processed
- * @property {string} FAILED - If checkout failed due to transactions not settling on chain
- * @property {string} INSUFFICIENT_FUNDS - If checkout failed due to insufficient funds
- */
-var CheckoutStatus;
-(function (CheckoutStatus) {
-    CheckoutStatus["SUCCESS"] = "SUCCESS";
-    CheckoutStatus["FAILED"] = "FAILED";
-    CheckoutStatus["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-})(CheckoutStatus || (CheckoutStatus = {}));
-/**
- * An enum representing the item types
- * @enum {string}
- * @property {string} NATIVE - If the item is a native token.
- * @property {string} ERC20 - If the item is an ERC20 token.
- * @property {string} ERC721 - If the item is an ERC721 token.
- */
-var ItemType;
-(function (ItemType) {
-    ItemType["NATIVE"] = "NATIVE";
-    ItemType["ERC20"] = "ERC20";
-    ItemType["ERC721"] = "ERC721";
-})(ItemType || (ItemType = {}));
-/**
- * An enum representing transaction or gas types
- * @enum {string}
- * @property {string} TRANSACTION - If the type is a transaction
- * @property {string} GAS - If the type is the gas amount
- */
-var TransactionOrGasType;
-(function (TransactionOrGasType) {
-    TransactionOrGasType["TRANSACTION"] = "TRANSACTION";
-    TransactionOrGasType["GAS"] = "GAS";
-})(TransactionOrGasType || (TransactionOrGasType = {}));
-/**
- * An enum representing the gas token types
- * @enum {string}
- * @property {string} NATIVE - If the gas token is a native token.
- * @property {string} ERC20 - If the gas token is an ERC20 token.
- */
-var GasTokenType;
-(function (GasTokenType) {
-    GasTokenType["NATIVE"] = "NATIVE";
-    GasTokenType["ERC20"] = "ERC20";
-})(GasTokenType || (GasTokenType = {}));
-/**
- * An enum representing the routing outcome types
- * @enum {string}
- * @property {string} ROUTES_FOUND - If funding routes were found for the transaction.
- * @property {string} NO_ROUTES_FOUND - If no funding routes were found for the transaction.
- * @property {string} NO_ROUTE_OPTIONS - If no routing options were available for the transaction.
- */
-var RoutingOutcomeType;
-(function (RoutingOutcomeType) {
-    RoutingOutcomeType["ROUTES_FOUND"] = "ROUTES_FOUND";
-    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} BRIDGE - If the funding step is a bridge.
- * @property {string} SWAP - If the funding step is a swap.
- * @property {string} ONRAMP - If the funding step is an onramp.
+ * An enum representing the funding step types
+ * @enum {string}
+ * @property {string} BRIDGE - If the funding step is a bridge.
+ * @property {string} SWAP - If the funding step is a swap.
+ * @property {string} ONRAMP - If the funding step is an onramp.
  */
 var FundingStepType;
 (function (FundingStepType) {
@@ -22112,158 +21770,507 @@ fn, customError) => {
     }
 };
 
-// this function needs to be in a separate file to prevent circular dependencies with ./network
-// this gives us access to the properties of the underlying provider object
-async function getUnderlyingChainId(web3Provider) {
-    if (!web3Provider.provider?.request) {
-        throw new CheckoutError('Parsed provider is not a valid Web3Provider', CheckoutErrorType.WEB3_PROVIDER_ERROR);
-    }
-    const chainId = await web3Provider.provider.request({
-        method: WalletAction.GET_CHAINID,
-        params: [],
-    });
-    return parseInt(chainId, 16);
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const UNRECOGNISED_CHAIN_ERROR_CODE = 4902; // error code (MetaMask)
-// these functions should not be exported. These functions should be used as part of an exported function e.g switchWalletNetwork() above.
-// make sure to check if(provider.provider?.request) in the exported function and throw an error
-// eslint-disable-next-line consistent-return
-async function switchNetworkInWallet(networkMap, web3Provider, chainId) {
-    if (web3Provider.provider?.request) {
-        return await web3Provider.provider.request({
-            method: WalletAction.SWITCH_NETWORK,
-            params: [
-                {
-                    chainId: networkMap.get(chainId)?.chainIdHex,
-                },
-            ],
-        });
-    }
-}
-// TODO: Should these functions always return something?
-// eslint-disable-next-line consistent-return
-async function addNetworkToWallet(networkMap, web3Provider, chainId) {
-    if (web3Provider.provider?.request) {
-        const networkDetails = networkMap.get(chainId);
-        const addNetwork = {
-            chainId: networkDetails?.chainIdHex,
-            chainName: networkDetails?.chainName,
-            rpcUrls: networkDetails?.rpcUrls,
-            nativeCurrency: networkDetails?.nativeCurrency,
-            blockExplorerUrls: networkDetails?.blockExplorerUrls,
-        };
-        return await web3Provider.provider.request({
-            method: WalletAction.ADD_NETWORK,
-            params: [addNetwork],
-        });
-    }
-}
-async function getNetworkAllowList(config, { type = NetworkFilterTypes.ALL, exclude }) {
-    const { networkMap } = config;
-    const allowedNetworkConfig = (await config.remote.getConfig('allowedNetworks'));
-    const list = allowedNetworkConfig.filter((network) => {
-        const allowAllTokens = type === NetworkFilterTypes.ALL;
-        const networkNotExcluded = !(exclude || [])
-            .map((exc) => exc.chainId)
-            .includes(network.chainId);
-        return allowAllTokens && networkNotExcluded;
-    });
-    const allowedNetworks = [];
-    list.forEach((element) => {
-        const newNetwork = networkMap.get(element.chainId);
-        if (newNetwork) {
-            allowedNetworks.push({
-                name: newNetwork.chainName,
-                chainId: parseInt(newNetwork.chainIdHex, 16),
-                nativeCurrency: newNetwork.nativeCurrency,
-                isSupported: true,
-            });
-        }
-    });
-    return {
-        networks: allowedNetworks,
-    };
-}
-async function getNetworkInfo(config, web3Provider) {
-    const { networkMap } = config;
-    return withCheckoutError(async () => {
-        try {
-            const network = await web3Provider.getNetwork();
-            if (Array.from(networkMap.keys()).includes(network.chainId)) {
-                const chainIdNetworkInfo = networkMap.get(network.chainId);
-                return {
-                    name: chainIdNetworkInfo.chainName,
-                    chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
-                    nativeCurrency: chainIdNetworkInfo.nativeCurrency,
-                    isSupported: true,
-                };
-            }
-            return {
-                chainId: network.chainId,
-                name: network.name,
-                isSupported: false,
-            };
-        }
-        catch (err) {
-            const chainId = await getUnderlyingChainId(web3Provider);
-            const isSupported = Array.from(networkMap.keys()).includes(chainId);
-            return {
-                chainId,
-                isSupported,
-            };
-        }
-    }, {
-        type: CheckoutErrorType.GET_NETWORK_INFO_ERROR,
-    });
-}
-async function switchWalletNetwork(config, web3Provider, chainId) {
-    const { networkMap } = config;
-    const allowedNetworks = await getNetworkAllowList(config, {
-        type: NetworkFilterTypes.ALL,
-    });
-    if (!allowedNetworks.networks.some((network) => network.chainId === chainId)) {
-        throw new CheckoutError(`Chain:${chainId} is not a supported chain`, CheckoutErrorType.CHAIN_NOT_SUPPORTED_ERROR);
-    }
-    if (web3Provider.provider?.isPassport) {
-        throw new CheckoutError('Switching networks with Passport provider is not supported', CheckoutErrorType.SWITCH_NETWORK_UNSUPPORTED);
-    }
-    // WT-1146 - Refer to the README in this folder for explanation on the switch network flow
-    try {
-        await switchNetworkInWallet(networkMap, web3Provider, chainId);
-    }
-    catch (err) {
-        if (err.code === UNRECOGNISED_CHAIN_ERROR_CODE) {
-            try {
-                await addNetworkToWallet(networkMap, web3Provider, chainId);
-                // eslint-disable-next-line @typescript-eslint/no-shadow
-            }
-            catch (err) {
-                throw new CheckoutError('User cancelled add network request', CheckoutErrorType.USER_REJECTED_REQUEST_ERROR);
-            }
-        }
-        else {
-            throw new CheckoutError('User cancelled switch network request', CheckoutErrorType.USER_REJECTED_REQUEST_ERROR);
-        }
-    }
-    const newProvider = new Web3Provider(web3Provider.provider);
-    const newProviderNetwork = await newProvider.getNetwork();
-    if (newProviderNetwork.chainId !== chainId) {
-        throw new CheckoutError('User cancelled switch network request', CheckoutErrorType.USER_REJECTED_REQUEST_ERROR);
-    }
-    const networkInfo = await getNetworkInfo(config, newProvider);
-    return {
-        network: networkInfo,
-        provider: newProvider,
-    };
-}
+// this function needs to be in a separate file to prevent circular dependencies with ./network
+// this gives us access to the properties of the underlying provider object
+async function getUnderlyingChainId(web3Provider) {
+    if (!web3Provider.provider?.request) {
+        throw new CheckoutError('Parsed provider is not a valid Web3Provider', CheckoutErrorType.WEB3_PROVIDER_ERROR);
+    }
+    const chainId = await web3Provider.provider.request({
+        method: WalletAction.GET_CHAINID,
+        params: [],
+    });
+    return parseInt(chainId, 16);
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const UNRECOGNISED_CHAIN_ERROR_CODE = 4902; // error code (MetaMask)
+// these functions should not be exported. These functions should be used as part of an exported function e.g switchWalletNetwork() above.
+// make sure to check if(provider.provider?.request) in the exported function and throw an error
+// eslint-disable-next-line consistent-return
+async function switchNetworkInWallet(networkMap, web3Provider, chainId) {
+    if (web3Provider.provider?.request) {
+        return await web3Provider.provider.request({
+            method: WalletAction.SWITCH_NETWORK,
+            params: [
+                {
+                    chainId: networkMap.get(chainId)?.chainIdHex,
+                },
+            ],
+        });
+    }
+}
+// TODO: Should these functions always return something?
+// eslint-disable-next-line consistent-return
+async function addNetworkToWallet(networkMap, web3Provider, chainId) {
+    if (web3Provider.provider?.request) {
+        const networkDetails = networkMap.get(chainId);
+        const addNetwork = {
+            chainId: networkDetails?.chainIdHex,
+            chainName: networkDetails?.chainName,
+            rpcUrls: networkDetails?.rpcUrls,
+            nativeCurrency: networkDetails?.nativeCurrency,
+            blockExplorerUrls: networkDetails?.blockExplorerUrls,
+        };
+        return await web3Provider.provider.request({
+            method: WalletAction.ADD_NETWORK,
+            params: [addNetwork],
+        });
+    }
+}
+async function getNetworkAllowList(config, { type = NetworkFilterTypes.ALL, exclude }) {
+    const { networkMap } = config;
+    const allowedNetworkConfig = (await config.remote.getConfig('allowedNetworks'));
+    const list = allowedNetworkConfig.filter((network) => {
+        const allowAllTokens = type === NetworkFilterTypes.ALL;
+        const networkNotExcluded = !(exclude || [])
+            .map((exc) => exc.chainId)
+            .includes(network.chainId);
+        return allowAllTokens && networkNotExcluded;
+    });
+    const allowedNetworks = [];
+    list.forEach((element) => {
+        const newNetwork = networkMap.get(element.chainId);
+        if (newNetwork) {
+            allowedNetworks.push({
+                name: newNetwork.chainName,
+                chainId: parseInt(newNetwork.chainIdHex, 16),
+                nativeCurrency: newNetwork.nativeCurrency,
+                isSupported: true,
+            });
+        }
+    });
+    return {
+        networks: allowedNetworks,
+    };
+}
+async function getNetworkInfo(config, web3Provider) {
+    const { networkMap } = config;
+    return withCheckoutError(async () => {
+        try {
+            const network = await web3Provider.getNetwork();
+            if (Array.from(networkMap.keys()).includes(network.chainId)) {
+                const chainIdNetworkInfo = networkMap.get(network.chainId);
+                return {
+                    name: chainIdNetworkInfo.chainName,
+                    chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
+                    nativeCurrency: chainIdNetworkInfo.nativeCurrency,
+                    isSupported: true,
+                };
+            }
+            return {
+                chainId: network.chainId,
+                name: network.name,
+                isSupported: false,
+            };
+        }
+        catch (err) {
+            const chainId = await getUnderlyingChainId(web3Provider);
+            const isSupported = Array.from(networkMap.keys()).includes(chainId);
+            return {
+                chainId,
+                isSupported,
+            };
+        }
+    }, {
+        type: CheckoutErrorType.GET_NETWORK_INFO_ERROR,
+    });
+}
+async function switchWalletNetwork(config, web3Provider, chainId) {
+    const { networkMap } = config;
+    const allowedNetworks = await getNetworkAllowList(config, {
+        type: NetworkFilterTypes.ALL,
+    });
+    if (!allowedNetworks.networks.some((network) => network.chainId === chainId)) {
+        throw new CheckoutError(`Chain:${chainId} is not a supported chain`, CheckoutErrorType.CHAIN_NOT_SUPPORTED_ERROR);
+    }
+    if (web3Provider.provider?.isPassport) {
+        throw new CheckoutError('Switching networks with Passport provider is not supported', CheckoutErrorType.SWITCH_NETWORK_UNSUPPORTED);
+    }
+    // WT-1146 - Refer to the README in this folder for explanation on the switch network flow
+    try {
+        await switchNetworkInWallet(networkMap, web3Provider, chainId);
+    }
+    catch (err) {
+        if (err.code === UNRECOGNISED_CHAIN_ERROR_CODE) {
+            try {
+                await addNetworkToWallet(networkMap, web3Provider, chainId);
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+            }
+            catch (err) {
+                throw new CheckoutError('User cancelled add network request', CheckoutErrorType.USER_REJECTED_REQUEST_ERROR);
+            }
+        }
+        else {
+            throw new CheckoutError('User cancelled switch network request', CheckoutErrorType.USER_REJECTED_REQUEST_ERROR);
+        }
+    }
+    const newProvider = new Web3Provider(web3Provider.provider);
+    const newProviderNetwork = await newProvider.getNetwork();
+    if (newProviderNetwork.chainId !== chainId) {
+        throw new CheckoutError('User cancelled switch network request', CheckoutErrorType.USER_REJECTED_REQUEST_ERROR);
+    }
+    const networkInfo = await getNetworkInfo(config, newProvider);
+    return {
+        network: networkInfo,
+        provider: newProvider,
+    };
+}
+
+const ENV_DEVELOPMENT = 'development';
+const DEFAULT_TOKEN_DECIMALS$1 = 18;
+const NATIVE = 'native';
+const ZKEVM_NATIVE_TOKEN = {
+    name: 'IMX',
+    symbol: 'IMX',
+    decimals: DEFAULT_TOKEN_DECIMALS$1,
+};
+/**
+ * Base URL for the Immutable API based on the environment.
+ * @property {string} DEVELOPMENT - The base URL for the development environment.
+ * @property {string} SANDBOX - The base URL for the sandbox environment.
+ * @property {string} PRODUCTION - The base URL for the production environment.
+ */
+const IMMUTABLE_API_BASE_URL = {
+    [ENV_DEVELOPMENT]: 'https://api.dev.immutable.com',
+    [Environment$1.SANDBOX]: 'https://api.sandbox.immutable.com',
+    [Environment$1.PRODUCTION]: 'https://api.immutable.com',
+};
+/**
+ * Base URL for the checkout API based on the environment.
+ * @property {string} DEVELOPMENT - The base URL for the development environment.
+ * @property {string} SANDBOX - The base URL for the sandbox environment.
+ * @property {string} PRODUCTION - The base URL for the production environment.
+ */
+const CHECKOUT_API_BASE_URL = {
+    [ENV_DEVELOPMENT]: 'https://checkout-api.dev.immutable.com',
+    [Environment$1.SANDBOX]: 'https://checkout-api.sandbox.immutable.com',
+    [Environment$1.PRODUCTION]: 'https://checkout-api.immutable.com',
+};
+/**
+ * Smart Checkout routing default onramp enabled flag
+ */
+const DEFAULT_ON_RAMP_ENABLED = true;
+/**
+ * Smart Checkout routing default swap enabled flag
+ */
+const DEFAULT_SWAP_ENABLED = true;
+/**
+ * Smart Checkout routing default bridge enabled flag
+ */
+const DEFAULT_BRIDGE_ENABLED = true;
+const TRANSAK_API_BASE_URL = {
+    [Environment$1.SANDBOX]: 'https://global-stg.transak.com',
+    [Environment$1.PRODUCTION]: 'https://global.transak.com/',
+};
+const PRODUCTION_CHAIN_ID_NETWORK_MAP = new Map([
+    [
+        ChainId.ETHEREUM,
+        {
+            chainIdHex: `0x${ChainId.ETHEREUM.toString(16)}`,
+            chainName: ChainName.ETHEREUM,
+            rpcUrls: ['https://checkout-api.immutable.com/v1/rpc/eth-mainnet'],
+            nativeCurrency: {
+                name: ChainName.ETHEREUM,
+                symbol: 'ETH',
+                decimals: 18,
+            },
+            blockExplorerUrls: ['https://etherscan.io/'],
+        },
+    ],
+    [
+        ChainId.IMTBL_ZKEVM_MAINNET,
+        {
+            chainIdHex: `0x${ChainId.IMTBL_ZKEVM_MAINNET.toString(16)}`,
+            chainName: ChainName.IMTBL_ZKEVM_MAINNET,
+            rpcUrls: ['https://rpc.immutable.com'],
+            nativeCurrency: ZKEVM_NATIVE_TOKEN,
+        },
+    ],
+]);
+const SANDBOX_CHAIN_ID_NETWORK_MAP = new Map([
+    [
+        ChainId.SEPOLIA,
+        {
+            chainIdHex: `0x${ChainId.SEPOLIA.toString(16)}`,
+            chainName: ChainName.SEPOLIA,
+            rpcUrls: [
+                'https://checkout-api.sandbox.immutable.com/v1/rpc/eth-sepolia',
+            ],
+            nativeCurrency: {
+                name: 'Sep Eth',
+                symbol: 'ETH',
+                decimals: 18,
+            },
+            blockExplorerUrls: ['https://sepolia.etherscan.io/'],
+        },
+    ],
+    [
+        ChainId.IMTBL_ZKEVM_TESTNET,
+        {
+            chainIdHex: `0x${ChainId.IMTBL_ZKEVM_TESTNET.toString(16)}`,
+            chainName: ChainName.IMTBL_ZKEVM_TESTNET,
+            rpcUrls: ['https://rpc.testnet.immutable.com'],
+            nativeCurrency: ZKEVM_NATIVE_TOKEN,
+        },
+    ],
+]);
+const DEV_CHAIN_ID_NETWORK_MAP = new Map([
+    [
+        ChainId.SEPOLIA,
+        {
+            chainIdHex: `0x${ChainId.SEPOLIA.toString(16)}`,
+            chainName: ChainName.SEPOLIA,
+            rpcUrls: ['https://checkout-api.dev.immutable.com/v1/rpc/eth-sepolia'],
+            nativeCurrency: {
+                name: 'Sep Eth',
+                symbol: 'ETH',
+                decimals: 18,
+            },
+            blockExplorerUrls: ['https://sepolia.etherscan.io/'],
+        },
+    ],
+    [
+        ChainId.IMTBL_ZKEVM_DEVNET,
+        {
+            chainIdHex: `0x${ChainId.IMTBL_ZKEVM_DEVNET.toString(16)}`,
+            chainName: ChainName.IMTBL_ZKEVM_DEVNET,
+            rpcUrls: ['https://rpc.dev.immutable.com'],
+            nativeCurrency: ZKEVM_NATIVE_TOKEN,
+        },
+    ],
+]);
+/**
+ * Blockscout API configuration per chain
+ */
+const BLOCKSCOUT_CHAIN_URL_MAP = {
+    [ChainId.IMTBL_ZKEVM_TESTNET]: {
+        url: 'https://explorer.testnet.immutable.com',
+        nativeToken: SANDBOX_CHAIN_ID_NETWORK_MAP.get(ChainId.IMTBL_ZKEVM_TESTNET).nativeCurrency,
+    },
+    [ChainId.IMTBL_ZKEVM_MAINNET]: {
+        url: 'https://explorer.mainnet.immutable.com',
+        nativeToken: PRODUCTION_CHAIN_ID_NETWORK_MAP.get(ChainId.IMTBL_ZKEVM_MAINNET).nativeCurrency,
+    },
+    [ChainId.SEPOLIA]: {
+        url: 'https://eth-sepolia.blockscout.com',
+        nativeToken: SANDBOX_CHAIN_ID_NETWORK_MAP.get(ChainId.SEPOLIA).nativeCurrency,
+    },
+    [ChainId.ETHEREUM]: {
+        url: 'https://eth.blockscout.com/',
+        nativeToken: PRODUCTION_CHAIN_ID_NETWORK_MAP.get(ChainId.ETHEREUM).nativeCurrency,
+    },
+};
+const ERC20ABI = [
+    {
+        constant: true,
+        inputs: [],
+        name: 'name',
+        outputs: [
+            {
+                name: '',
+                type: 'string',
+            },
+        ],
+        payable: false,
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: 'decimals',
+        outputs: [
+            {
+                name: '',
+                type: 'uint8',
+            },
+        ],
+        payable: false,
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                name: '_owner',
+                type: 'address',
+            },
+        ],
+        name: 'balanceOf',
+        outputs: [
+            {
+                name: 'balance',
+                type: 'uint256',
+            },
+        ],
+        payable: false,
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: 'symbol',
+        outputs: [
+            {
+                name: '',
+                type: 'string',
+            },
+        ],
+        payable: false,
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                name: '_owner',
+                type: 'address',
+            },
+            {
+                name: '_spender',
+                type: 'address',
+            },
+        ],
+        name: 'allowance',
+        outputs: [
+            {
+                name: '',
+                type: 'uint256',
+            },
+        ],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        constant: false,
+        inputs: [
+            {
+                name: '_spender',
+                type: 'address',
+            },
+            {
+                name: '_value',
+                type: 'uint256',
+            },
+        ],
+        name: 'approve',
+        outputs: [
+            {
+                name: '',
+                type: 'bool',
+            },
+        ],
+        payable: false,
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];
+const ERC721ABI = [
+    {
+        constant: false,
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'to',
+                type: 'address',
+            },
+            {
+                internalType: 'uint256',
+                name: 'tokenId',
+                type: 'uint256',
+            },
+        ],
+        name: 'approve',
+        outputs: [],
+        payable: false,
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'owner',
+                type: 'address',
+            },
+            {
+                internalType: 'address',
+                name: 'operator',
+                type: 'address',
+            },
+        ],
+        name: 'isApprovedForAll',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool',
+            },
+        ],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'tokenId',
+                type: 'uint256',
+            },
+        ],
+        name: 'getApproved',
+        outputs: [
+            {
+                internalType: 'address',
+                name: '',
+                type: 'address',
+            },
+        ],
+        payable: false,
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'tokenId',
+                type: 'uint256',
+            },
+        ],
+        name: 'ownerOf',
+        outputs: [
+            {
+                internalType: 'address',
+                name: '',
+                type: 'address',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+// Gas overrides -- Anti-spam mechanism for when the baseFee drops low
+// https://github.com/immutable/imx-docs/blob/main/docs/main/zkEVM/overview/gas-configuration.md
+const GAS_OVERRIDES = {
+    maxFeePerGas: BigNumber$1.from(102e9),
+    maxPriorityFeePerGas: BigNumber$1.from(101e9),
+};
+
+const SDK_VERSION_MARKER = '0.33.0';
+// This SDK version is replaced by the `yarn build` command ran on the root level
+const globalPackageVersion = () => SDK_VERSION_MARKER;
 
 class RemoteConfigFetcher {
     isDevelopment;
     isProduction;
     configCache;
     tokensCache;
+    version = 'v1';
     constructor(params) {
         this.isDevelopment = params.isDevelopment;
         this.isProduction = params.isProduction;
@@ -22291,14 +22298,14 @@ class RemoteConfigFetcher {
     async loadConfig() {
         if (this.configCache)
             return this.configCache;
-        const response = await RemoteConfigFetcher.makeHttpRequest(`${this.getEndpoint()}/v1/config`);
+        const response = await RemoteConfigFetcher.makeHttpRequest(`${this.getEndpoint()}/${this.version}/config`);
         this.configCache = response.data;
         return this.configCache;
     }
     async loadConfigTokens() {
         if (this.tokensCache)
             return this.tokensCache;
-        const response = await RemoteConfigFetcher.makeHttpRequest(`${this.getEndpoint()}/v1/config/tokens`);
+        const response = await RemoteConfigFetcher.makeHttpRequest(`${this.getEndpoint()}/${this.version}/config/tokens`);
         this.tokensCache = response.data;
         return this.tokensCache;
     }
@@ -22414,6 +22421,7 @@ const getTokenAllowList = async (config, { type = TokenFilterTypes.ALL, chainId,
         tokens: tokens.filter((token) => !exclude.map((e) => e.address).includes(token.address || '')),
     };
 };
+const isNativeToken = (address) => !address || address.toLocaleLowerCase() === NATIVE;
 
 const CACHE_DATA_TTL = 60; // seconds
 /**
@@ -22613,7 +22621,7 @@ const getIndexerBalance = async (walletAddress, chainId, filterTokens) => {
     // Shuffle the mapping of the tokens configuration so it is a hashmap
     // for faster access to tokens config objects.
     const shouldFilter = filterTokens.length > 0;
-    const mapFilterTokens = Object.assign({}, ...(filterTokens.map((t) => ({ [t.address || '']: t }))));
+    const mapFilterTokens = Object.assign({}, ...(filterTokens.map((t) => ({ [t.address || NATIVE]: t }))));
     // Get blockscout client for the given chain
     let blockscoutClient = blockscoutClientMap.get(chainId);
     if (!blockscoutClient) {
@@ -22654,6 +22662,7 @@ const getIndexerBalance = async (walletAddress, chainId, filterTokens) => {
     const nativeBalances = async (client) => {
         try {
             const respNative = await client.getNativeTokenByWalletAddress({ walletAddress });
+            respNative.token.address ||= NATIVE;
             items.push(respNative);
         }
         catch (err) {
@@ -22696,8 +22705,7 @@ const getBalances = async (config, web3Provider, walletAddress, tokens) => {
     const allBalancePromises = [];
     tokens
         .forEach((token) => {
-        // Check for NATIVE token
-        if (!token.address || token.address === IMX_ADDRESS_ZKEVM) {
+        if (!token.address || token.address.toLocaleLowerCase() === NATIVE) {
             allBalancePromises.push(getBalance(config, web3Provider, walletAddress));
         }
         else {
@@ -22883,11 +22891,17 @@ async function getWalletAllowList(params) {
     };
 }
 
+const setTransactionGasLimits = (transaction) => {
+    const rawTx = transaction;
+    rawTx.maxFeePerGas = GAS_OVERRIDES.maxFeePerGas;
+    rawTx.maxPriorityFeePerGas = GAS_OVERRIDES.maxPriorityFeePerGas;
+    return rawTx;
+};
 const sendTransaction = async (web3Provider, transaction) => {
     try {
-        const transactionResponse = await web3Provider
-            .getSigner()
-            .sendTransaction(transaction);
+        const signer = web3Provider.getSigner();
+        const rawTx = setTransactionGasLimits(transaction);
+        const transactionResponse = await signer.sendTransaction(rawTx);
         return {
             transactionResponse,
         };
@@ -23050,25 +23064,21 @@ async function swapGasEstimator(config) {
         const exchange = await createExchangeInstance(chainId, config);
         // Create a fake transaction to get the gas from the quote
         const { swap } = await exchange.getUnsignedSwapTxFromAmountIn(DUMMY_WALLET_ADDRESS, inAddress, outAddress, BigNumber$1.from(utils.parseUnits('1', DEFAULT_TOKEN_DECIMALS)));
-        if (swap.gasFeeEstimate === null) {
+        if (!swap.gasFeeEstimate) {
             return {
                 gasEstimateType: GasEstimateType.SWAP,
                 gasFee: {},
             };
         }
-        let estimatedAmount;
-        if (swap.gasFeeEstimate.value) {
-            estimatedAmount = BigNumber$1.from(swap.gasFeeEstimate.value);
-        }
         return {
             gasEstimateType: GasEstimateType.SWAP,
             gasFee: {
-                estimatedAmount,
+                estimatedAmount: swap.gasFeeEstimate.value ? BigNumber$1.from(swap.gasFeeEstimate.value) : undefined,
                 token: {
-                    address: swap.gasFeeEstimate?.token.address,
-                    symbol: swap.gasFeeEstimate?.token.symbol ?? '',
-                    name: swap.gasFeeEstimate?.token.name ?? '',
-                    decimals: swap.gasFeeEstimate?.token.decimals ?? DEFAULT_TOKEN_DECIMALS,
+                    address: swap.gasFeeEstimate.token.address,
+                    symbol: swap.gasFeeEstimate.token.symbol ?? '',
+                    name: swap.gasFeeEstimate.token.name ?? '',
+                    decimals: swap.gasFeeEstimate.token.decimals ?? DEFAULT_TOKEN_DECIMALS,
                 },
             },
         };
@@ -23459,7 +23469,7 @@ const getTokensFromRequirements = (itemRequirements) => itemRequirements
     .map((itemRequirement) => {
     if (itemRequirement.type === ItemType.NATIVE) {
         return {
-            address: IMX_ADDRESS_ZKEVM,
+            address: NATIVE,
         };
     }
     return {
@@ -23519,8 +23529,7 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
     }
     else if (itemRequirement.type === ItemType.NATIVE) {
         itemBalanceResult = balances.find((balance) => {
-            return balance.token?.address === ''
-                || balance.token?.address === IMX_ADDRESS_ZKEVM;
+            return isNativeToken(balance.token?.address);
         });
     }
     // Calculate the balance delta
@@ -23548,7 +23557,6 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
                     name,
                     symbol,
                     decimals: DEFAULT_TOKEN_DECIMALS$1,
-                    address: IMX_ADDRESS_ZKEVM,
                 },
             };
         }
@@ -23607,9 +23615,13 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
 const getTokenBalances = async (config, provider, ownerAddress, itemRequirements) => {
     try {
         const tokenMap = new Map();
-        getTokensFromRequirements(itemRequirements).forEach((item) => tokenMap.set((item.address || '').toLocaleLowerCase(), item));
-        const { balances } = await getAllBalances(config, provider, ownerAddress);
-        return balances.filter((balance) => tokenMap.get((balance.token.address || '').toLocaleLowerCase()));
+        getTokensFromRequirements(itemRequirements).forEach((item) => {
+            if (!item.address)
+                return;
+            tokenMap.set(item.address.toLocaleLowerCase(), item);
+        });
+        const { balances } = await getAllBalances(config, provider, ownerAddress, getL2ChainId(config));
+        return balances.filter((balance) => tokenMap.get((balance.token.address || NATIVE).toLocaleLowerCase()));
     }
     catch (error) {
         throw new CheckoutError('Failed to get balances', CheckoutErrorType.GET_BALANCE_ERROR);
@@ -24015,7 +24027,7 @@ const constructFees$1 = (approvalGasFees, swapGasFees, swapFees) => {
 const constructSwapRoute = (chainId, fundsRequired, userBalance, fees) => {
     const tokenAddress = userBalance.token.address;
     let type = ItemType.ERC20;
-    if (tokenAddress === IMX_ADDRESS_ZKEVM) {
+    if (isNativeToken(tokenAddress)) {
         type = ItemType.NATIVE;
     }
     return {
@@ -24036,16 +24048,24 @@ const constructSwapRoute = (chainId, fundsRequired, userBalance, fees) => {
         fees,
     };
 };
+const isBalanceRequirementTokenValid = (balanceRequirement) => {
+    if (balanceRequirement.type === ItemType.ERC20) {
+        return !!balanceRequirement.required.token.address;
+    }
+    if (balanceRequirement.type === ItemType.NATIVE) {
+        return isNativeToken(balanceRequirement.required.token.address);
+    }
+    return false;
+};
 const getRequiredToken = (balanceRequirement) => {
     let address = '';
     let amount = BigNumber$1.from(0);
     switch (balanceRequirement.type) {
         case ItemType.ERC20:
-            address = balanceRequirement.required.token.address ?? '';
+            address = balanceRequirement.required.token.address;
             amount = balanceRequirement.delta.balance;
             break;
         case ItemType.NATIVE:
-            address = IMX_ADDRESS_ZKEVM;
             amount = balanceRequirement.delta.balance;
             break;
     }
@@ -24066,7 +24086,8 @@ const checkUserCanCoverApprovalFees = (l2Balances, approval) => {
         };
     }
     // Find the users balance of the approval token
-    const l2BalanceOfApprovalToken = l2Balances.find((balance) => balance.token.address === approvalGasTokenAddress);
+    const l2BalanceOfApprovalToken = l2Balances.find((balance) => (isNativeToken(balance.token.address) && isNativeToken(approvalGasTokenAddress))
+        || balance.token.address === approvalGasTokenAddress);
     if (!l2BalanceOfApprovalToken)
         return { sufficient: false, approvalGasFee, approvalGasTokenAddress };
     // If the user does not have enough of the token to cover approval fees then return sufficient false
@@ -24084,7 +24105,7 @@ const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFees, swapFe
     // 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
-    if (approvalFees.approvalGasTokenAddress !== '') {
+    if (approvalFees.approvalGasFee.gt(BigNumber$1.from(0))) {
         feeMap.set(approvalFees.approvalGasTokenAddress, approvalFees.approvalGasFee);
     }
     // Add the swap gas fee to list of fees
@@ -24120,7 +24141,8 @@ const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFees, swapFe
     for (const [tokenAddress, fee] of feeMap.entries()) {
         if (fee === BigNumber$1.from(0))
             continue;
-        const l2BalanceOfFeeToken = l2Balances.find((balance) => balance.token.address === tokenAddress);
+        const l2BalanceOfFeeToken = l2Balances.find((balance) => (isNativeToken(balance.token.address) && isNativeToken(tokenAddress))
+            || balance.token.address === tokenAddress);
         if (!l2BalanceOfFeeToken) {
             return false;
         }
@@ -24172,9 +24194,9 @@ const swapRoute = async (config, availableRoutingOptions, walletAddress, balance
         return fundingSteps;
     if (swappableTokens.length === 0)
         return fundingSteps;
-    const requiredToken = getRequiredToken(balanceRequirement);
-    if (requiredToken.address === '')
+    if (!isBalanceRequirementTokenValid(balanceRequirement))
         return fundingSteps;
+    const requiredToken = getRequiredToken(balanceRequirement);
     const chainId = getL2ChainId(config);
     const l2TokenBalanceResult = tokenBalanceResults.get(chainId);
     if (!l2TokenBalanceResult)
@@ -24271,7 +24293,7 @@ const allowListCheck = async (config, tokenBalances, availableRoutingOptions) =>
 
 const getEthBalance = (balances) => {
     for (const balance of balances.balances) {
-        if (!balance.token.address || balance.token.address === '') {
+        if (isNativeToken(balance.token.address)) {
             return balance.balance;
         }
     }
@@ -24327,25 +24349,28 @@ const getImxL1Representation = async (chainId, config) => {
     return imxMappingConfig[chainId] ?? '';
 };
 const fetchL1Representation = async (config, l2address) => {
-    if (l2address === '')
-        return { l1address: '', l2address };
-    if (l2address === IMX_ADDRESS_ZKEVM) {
+    if (isNativeToken(l2address)) {
         return {
             l1address: await getImxL1Representation(getL1ChainId(config), config),
-            l2address: IMX_ADDRESS_ZKEVM,
+            l2address: NATIVE,
         };
     }
     const chainName = getIndexerChainName(getL2ChainId(config));
-    if (chainName === '')
-        return { l1address: '', l2address }; // Chain name not a valid indexer chain name
     const blockchainData = createBlockchainDataInstance(config);
     const tokenData = await blockchainData.getToken({
         chainName,
         contractAddress: l2address,
     });
+    // TODO: When bridge is ready we need to understand how L2 ETH will be mapped back to L1 ETH
     const l1address = tokenData.result.root_contract_address;
+    if (l1address === INDEXER_ETH_ROOT_CONTRACT_ADDRESS) {
+        return {
+            l1address: 'native',
+            l2address,
+        };
+    }
     if (l1address === null)
-        return { l1address: '', l2address }; // No L1 representation of this token
+        return undefined; // No L1 representation of this token
     return {
         l1address,
         l2address,
@@ -24432,16 +24457,9 @@ const constructBridgeFundingRoute = (chainId, balance, bridgeRequirement, itemTy
     },
     fees,
 });
-const isNativeEth = (address) => {
-    if (!address || address === '')
-        return true;
-    return false;
-};
 const bridgeRoute = async (config, readOnlyProviders, depositorAddress, availableRoutingOptions, bridgeRequirement, tokenBalanceResults, feeEstimates) => {
     if (!availableRoutingOptions.bridge)
         return undefined;
-    if (bridgeRequirement.l2address === undefined || bridgeRequirement.l2address === '')
-        return undefined;
     const chainId = getL1ChainId(config);
     const tokenBalanceResult = tokenBalanceResults.get(chainId);
     const l1provider = readOnlyProviders.get(chainId);
@@ -24459,12 +24477,11 @@ const bridgeRoute = async (config, readOnlyProviders, depositorAddress, availabl
     if (!hasSufficientL1Eth(tokenBalanceResult, bridgeFeeEstimate.totalFees))
         return undefined;
     const l1RepresentationResult = await fetchL1Representation(config, bridgeRequirement.l2address);
-    // No mapping on L1 for this token
-    const { l1address } = l1RepresentationResult;
-    if (l1address === '')
+    if (!l1RepresentationResult)
         return undefined;
     // Ensure l1address is in the allowed token list
-    if (l1address === INDEXER_ETH_ROOT_CONTRACT_ADDRESS) {
+    const { l1address } = l1RepresentationResult;
+    if (isNativeToken(l1address)) {
         if (!allowedTokenList.find((token) => !('address' in token)))
             return undefined;
     }
@@ -24474,9 +24491,9 @@ const bridgeRoute = async (config, readOnlyProviders, depositorAddress, availabl
     const gasForApproval = await estimateGasForBridgeApproval(config, readOnlyProviders, l1provider, depositorAddress, l1address, bridgeRequirement.amount);
     let totalFees = bridgeFeeEstimate.bridgeFee.estimatedAmount;
     // If the L1 representation of the requirement is ETH then find the ETH balance and check if the balance covers the delta
-    if (l1address === INDEXER_ETH_ROOT_CONTRACT_ADDRESS) {
+    if (isNativeToken(l1address)) {
         const nativeETHBalance = tokenBalanceResult.balances
-            .find((balance) => isNativeEth(balance.token.address));
+            .find((balance) => isNativeToken(balance.token.address));
         if (bridgeFeeEstimate.gasFee.estimatedAmount) {
             totalFees = totalFees.add(bridgeFeeEstimate.gasFee.estimatedAmount);
         }
@@ -24632,8 +24649,10 @@ const constructBridgeRequirements = (dexQuotes, l1balances, l2balances, l1tol2ad
 };
 
 const fetchL1ToL2Mappings = async (config, swappableTokens) => {
-    const l1tol2addressMappingPromises = swappableTokens.map((token) => fetchL1Representation(config, token.address ?? ''));
-    return await Promise.all(l1tol2addressMappingPromises);
+    const l1tol2addressMappingPromises = swappableTokens
+        .map((token) => fetchL1Representation(config, token.address ?? ''));
+    const mappings = await Promise.all(l1tol2addressMappingPromises);
+    return mappings.filter((mapping) => mapping !== undefined);
 };
 
 // Fetch all the dex quotes from the list of swappable tokens
@@ -24673,10 +24692,7 @@ const abortBridgeAndSwap = (bridgeableTokens, swappableTokens, l1balances, l2bal
 const filterSwappableTokensByBridgeableAddresses = (requiredTokenAddress, bridgeableTokens, swappableTokens, l1tol2Addresses) => {
     const filteredSwappableTokens = [];
     for (const addresses of l1tol2Addresses) {
-        if (addresses.l1address === '')
-            continue;
-        if (addresses.l2address === '')
-            continue;
+        // TODO: Check for ETH (native) L1 in bridgeableTokens first
         if (!bridgeableTokens.includes(addresses.l1address))
             continue;
         // Filter out the token that is required from the swappable tokens list
@@ -24865,7 +24881,7 @@ const onRampRoute = async (config, availableRoutingOptions, balanceRequirement)
         type: FundingStepType.ONRAMP,
         chainId: getL2ChainId(config),
         fundingItem: {
-            type: required.token.address === IMX_ADDRESS_ZKEVM ? ItemType.NATIVE : ItemType.ERC20,
+            type: isNativeToken(required.token.address) ? ItemType.NATIVE : ItemType.ERC20,
             fundsRequired: {
                 amount: delta.balance,
                 formattedAmount: delta.formattedBalance,
@@ -25101,8 +25117,8 @@ var SignTransactionStatusType;
 const signApprovalTransactions = async (provider, approvalTransactions) => {
     let receipts = [];
     try {
-        const response = await Promise.all(approvalTransactions.map((transaction) => provider.getSigner().sendTransaction(transaction)));
-        receipts = await Promise.all(response.map((transaction) => transaction.wait()));
+        const response = await Promise.all(approvalTransactions.map((transaction) => sendTransaction(provider, transaction)));
+        receipts = await Promise.all(response.map((transaction) => transaction.transactionResponse.wait()));
     }
     catch (err) {
         throw new CheckoutError('An error occurred while executing the approval transaction', CheckoutErrorType.EXECUTE_APPROVAL_TRANSACTION_ERROR, {
@@ -25125,8 +25141,8 @@ const signApprovalTransactions = async (provider, approvalTransactions) => {
 const signFulfillmentTransactions = async (provider, fulfillmentTransactions) => {
     let receipts = [];
     try {
-        const response = await Promise.all(fulfillmentTransactions.map((transaction) => provider.getSigner().sendTransaction(transaction)));
-        receipts = await Promise.all(response.map((transaction) => transaction.wait()));
+        const response = await Promise.all(fulfillmentTransactions.map((transaction) => sendTransaction(provider, transaction)));
+        receipts = await Promise.all(response.map((transaction) => transaction.transactionResponse.wait()));
     }
     catch (err) {
         throw new CheckoutError('An error occurred while executing the fulfillment transaction', CheckoutErrorType.EXECUTE_FULFILLMENT_TRANSACTION_ERROR, {
@@ -25702,10 +25718,6 @@ async function getItemRequirementsFromRequirements(provider, requirements) {
     return itemRequirements;
 }
 
-const SDK_VERSION_MARKER = '0.31.3';
-// This SDK version is replaced by the `yarn build` command ran on the root level
-const globalPackageVersion = () => SDK_VERSION_MARKER;
-
 /**
  * Validates and builds a version string based on the given SemanticVersion object.
  * If the version is undefined or has an invalid major version, it returns the default checkout version.