@imtbl/sdk 0.31.3 → 0.33.0

package/dist/index.cjs

@@ -62,7 +62,6 @@ class ImmutableConfiguration {
 }
 const API_KEY_PREFIX = 'sk_imapik-';
 const PUBLISHABLE_KEY_PREFIX = 'pk_imapik-';
-const PUBLISHABLE_KEY_LENGTH = 30;
 const addApiKeyToAxiosHeader = (apiKey) => {
     if (!apiKey.startsWith(API_KEY_PREFIX)) {
         throw new Error('Invalid API key. Create your api key in Immutable developer hub. https://hub.immutable.com');
@@ -70,7 +69,7 @@ const addApiKeyToAxiosHeader = (apiKey) => {
     globalAxios$1.defaults.headers.common['x-immutable-api-key'] = apiKey;
 };
 const addPublishableKeyToAxiosHeader = (publishableKey) => {
-    if (!publishableKey.startsWith(PUBLISHABLE_KEY_PREFIX) || publishableKey.length !== PUBLISHABLE_KEY_LENGTH) {
+    if (!publishableKey.startsWith(PUBLISHABLE_KEY_PREFIX)) {
         throw new Error('Invalid Publishable key. Create your Publishable key in Immutable developer hub.'
             + ' https://hub.immutable.com');
     }
@@ -3792,7 +3791,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.31.3' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.33.0' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3852,7 +3851,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
@@ -4263,7 +4262,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.31.3',
+    sdkVersion: 'ts-immutable-sdk-0.33.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -28688,13 +28687,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,
@@ -29006,7 +29005,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
  */
@@ -29131,9 +29130,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) {
@@ -30012,14 +30008,333 @@ const validateProviderDefaults = {
     allowUnsupportedProvider: false,
 };
 
+/**
+ * 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.
+ */
+var FundingStepType;
+(function (FundingStepType) {
+    FundingStepType["BRIDGE"] = "BRIDGE";
+    FundingStepType["SWAP"] = "SWAP";
+    FundingStepType["ONRAMP"] = "ONRAMP";
+})(FundingStepType || (FundingStepType = {}));
+
+// import { Passport } from '@imtbl/passport';
+/**
+ * An enum representing the type of exchange.
+ * @enum {string}
+ * @property {string} ONRAMP - The exchange type for transacting.
+ */
+var ExchangeType;
+(function (ExchangeType) {
+    ExchangeType["ONRAMP"] = "onramp";
+})(ExchangeType || (ExchangeType = {}));
+
+/**
+ * Enum representing different types of errors that can occur during the checkout process.
+ */
+var CheckoutErrorType;
+(function (CheckoutErrorType) {
+    CheckoutErrorType["WEB3_PROVIDER_ERROR"] = "WEB3_PROVIDER_ERROR";
+    CheckoutErrorType["PROVIDER_ERROR"] = "PROVIDER_ERROR";
+    CheckoutErrorType["DEFAULT_PROVIDER_ERROR"] = "DEFAULT_PROVIDER_ERROR";
+    CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
+    CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
+    CheckoutErrorType["GET_INDEXER_BALANCE_ERROR"] = "GET_INDEXER_BALANCE_ERROR";
+    CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_ERROR";
+    CheckoutErrorType["GET_ERC721_BALANCE_ERROR"] = "GET_ERC721_BALANCE_ERROR";
+    CheckoutErrorType["GET_NETWORK_INFO_ERROR"] = "GET_NETWORK_INFO_ERROR";
+    CheckoutErrorType["METAMASK_PROVIDER_ERROR"] = "METAMASK_PROVIDER_ERROR";
+    CheckoutErrorType["CHAIN_NOT_SUPPORTED_ERROR"] = "CHAIN_NOT_SUPPORTED_ERROR";
+    CheckoutErrorType["PROVIDER_REQUEST_MISSING_ERROR"] = "PROVIDER_REQUEST_MISSING_ERROR";
+    CheckoutErrorType["PROVIDER_REQUEST_FAILED_ERROR"] = "PROVIDER_REQUEST_FAILED_ERROR";
+    CheckoutErrorType["USER_REJECTED_REQUEST_ERROR"] = "USER_REJECTED_REQUEST_ERROR";
+    CheckoutErrorType["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+    CheckoutErrorType["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
+    CheckoutErrorType["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
+    CheckoutErrorType["INVALID_GAS_ESTIMATE_TYPE"] = "INVALID_GAS_ESTIMATE_TYPE";
+    CheckoutErrorType["UNSUPPORTED_TOKEN_TYPE_ERROR"] = "UNSUPPORTED_TOKEN_TYPE_ERROR";
+    CheckoutErrorType["UNSUPPORTED_BALANCE_REQUIREMENT_ERROR"] = "UNSUPPORTED_BALANCE_REQUIREMENT_ERROR";
+    CheckoutErrorType["GET_ORDER_LISTING_ERROR"] = "GET_ORDER_LISTING_ERROR";
+    CheckoutErrorType["CANCEL_ORDER_LISTING_ERROR"] = "CANCEL_ORDER_LISTING_ERROR";
+    CheckoutErrorType["PREPARE_ORDER_LISTING_ERROR"] = "PREPARE_ORDER_LISTING_ERROR";
+    CheckoutErrorType["CREATE_ORDER_LISTING_ERROR"] = "CREATE_ORDER_LISTING_ERROR";
+    CheckoutErrorType["FULFILL_ORDER_LISTING_ERROR"] = "FULFILL_ORDER_LISTING_ERROR";
+    CheckoutErrorType["SWITCH_NETWORK_UNSUPPORTED"] = "SWITCH_NETWORK_UNSUPPORTED";
+    CheckoutErrorType["GET_ERC20_ALLOWANCE_ERROR"] = "GET_ERC20_ALLOWANCE_ERROR";
+    CheckoutErrorType["GET_ERC721_ALLOWANCE_ERROR"] = "GET_ERC721_ALLOWANCE_ERROR";
+    CheckoutErrorType["EXECUTE_APPROVAL_TRANSACTION_ERROR"] = "EXECUTE_APPROVAL_TRANSACTION_ERROR";
+    CheckoutErrorType["EXECUTE_FULFILLMENT_TRANSACTION_ERROR"] = "EXECUTE_FULFILLMENT_TRANSACTION_ERROR";
+    CheckoutErrorType["SIGN_MESSAGE_ERROR"] = "SIGN_MESSAGE_ERROR";
+    CheckoutErrorType["BRIDGE_GAS_ESTIMATE_ERROR"] = "BRIDGE_GAS_ESTIMATE_ERROR";
+    CheckoutErrorType["ORDER_FEE_ERROR"] = "ORDER_FEE_ERROR";
+    CheckoutErrorType["ITEM_REQUIREMENTS_ERROR"] = "ITEM_REQUIREMENTS_ERROR";
+    CheckoutErrorType["API_ERROR"] = "API_ERROR";
+    CheckoutErrorType["ORDER_EXPIRED_ERROR"] = "ORDER_EXPIRED_ERROR";
+    CheckoutErrorType["WIDGETS_SCRIPT_LOAD_ERROR"] = "WIDGETS_SCRIPT_LOAD_ERROR";
+})(CheckoutErrorType || (CheckoutErrorType = {}));
+/* The CheckoutError class is a custom error class in TypeScript that includes a message, type, and
+optional data object. */
+class CheckoutError extends Error {
+    message;
+    type;
+    data;
+    constructor(message, type, data) {
+        super(message);
+        this.message = message;
+        this.type = type;
+        this.data = data;
+    }
+}
+var CheckoutInternalErrorType;
+(function (CheckoutInternalErrorType) {
+    CheckoutInternalErrorType["REJECTED_SWITCH_AFTER_ADDING_NETWORK"] = "REJECTED_SWITCH_AFTER_ADDING_NETWORK";
+})(CheckoutInternalErrorType || (CheckoutInternalErrorType = {}));
+const withCheckoutError = async (
+/**
+ * Wraps a function that returns a Promise and catches any errors that occur. If an error is caught,
+ * it is wrapped in a CheckoutError and rethrown.
+ */
+fn, customError) => {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        const cause = `${error.message}` || 'UnknownError';
+        const errorMessage = customError.message
+            ? `[${customError.type}]:${customError.message}. Cause:${cause}`
+            : `[${customError.type}] Cause:${cause}`;
+        if (error instanceof CheckoutError) {
+            throw new CheckoutError(errorMessage, customError.type, {
+                ...customError.data,
+                innerErrorType: error.type,
+                ...error.data,
+            });
+        }
+        throw new CheckoutError(errorMessage, customError.type, {
+            ...customError.data,
+        });
+    }
+};
+
+// 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 providers.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 IMX_ADDRESS_ZKEVM = '0x0000000000000000000000000000000000001010';
 const DEFAULT_TOKEN_DECIMALS$1 = 18;
+const NATIVE = 'native';
 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.
@@ -30350,332 +30665,23 @@ const ERC721ABI = [
         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.
- */
-var FundingStepType;
-(function (FundingStepType) {
-    FundingStepType["BRIDGE"] = "BRIDGE";
-    FundingStepType["SWAP"] = "SWAP";
-    FundingStepType["ONRAMP"] = "ONRAMP";
-})(FundingStepType || (FundingStepType = {}));
-
-// import { Passport } from '@imtbl/passport';
-/**
- * An enum representing the type of exchange.
- * @enum {string}
- * @property {string} ONRAMP - The exchange type for transacting.
- */
-var ExchangeType;
-(function (ExchangeType) {
-    ExchangeType["ONRAMP"] = "onramp";
-})(ExchangeType || (ExchangeType = {}));
-
-/**
- * Enum representing different types of errors that can occur during the checkout process.
- */
-var CheckoutErrorType;
-(function (CheckoutErrorType) {
-    CheckoutErrorType["WEB3_PROVIDER_ERROR"] = "WEB3_PROVIDER_ERROR";
-    CheckoutErrorType["PROVIDER_ERROR"] = "PROVIDER_ERROR";
-    CheckoutErrorType["DEFAULT_PROVIDER_ERROR"] = "DEFAULT_PROVIDER_ERROR";
-    CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
-    CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
-    CheckoutErrorType["GET_INDEXER_BALANCE_ERROR"] = "GET_INDEXER_BALANCE_ERROR";
-    CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_ERROR";
-    CheckoutErrorType["GET_ERC721_BALANCE_ERROR"] = "GET_ERC721_BALANCE_ERROR";
-    CheckoutErrorType["GET_NETWORK_INFO_ERROR"] = "GET_NETWORK_INFO_ERROR";
-    CheckoutErrorType["METAMASK_PROVIDER_ERROR"] = "METAMASK_PROVIDER_ERROR";
-    CheckoutErrorType["CHAIN_NOT_SUPPORTED_ERROR"] = "CHAIN_NOT_SUPPORTED_ERROR";
-    CheckoutErrorType["PROVIDER_REQUEST_MISSING_ERROR"] = "PROVIDER_REQUEST_MISSING_ERROR";
-    CheckoutErrorType["PROVIDER_REQUEST_FAILED_ERROR"] = "PROVIDER_REQUEST_FAILED_ERROR";
-    CheckoutErrorType["USER_REJECTED_REQUEST_ERROR"] = "USER_REJECTED_REQUEST_ERROR";
-    CheckoutErrorType["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
-    CheckoutErrorType["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-    CheckoutErrorType["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
-    CheckoutErrorType["INVALID_GAS_ESTIMATE_TYPE"] = "INVALID_GAS_ESTIMATE_TYPE";
-    CheckoutErrorType["UNSUPPORTED_TOKEN_TYPE_ERROR"] = "UNSUPPORTED_TOKEN_TYPE_ERROR";
-    CheckoutErrorType["UNSUPPORTED_BALANCE_REQUIREMENT_ERROR"] = "UNSUPPORTED_BALANCE_REQUIREMENT_ERROR";
-    CheckoutErrorType["GET_ORDER_LISTING_ERROR"] = "GET_ORDER_LISTING_ERROR";
-    CheckoutErrorType["CANCEL_ORDER_LISTING_ERROR"] = "CANCEL_ORDER_LISTING_ERROR";
-    CheckoutErrorType["PREPARE_ORDER_LISTING_ERROR"] = "PREPARE_ORDER_LISTING_ERROR";
-    CheckoutErrorType["CREATE_ORDER_LISTING_ERROR"] = "CREATE_ORDER_LISTING_ERROR";
-    CheckoutErrorType["FULFILL_ORDER_LISTING_ERROR"] = "FULFILL_ORDER_LISTING_ERROR";
-    CheckoutErrorType["SWITCH_NETWORK_UNSUPPORTED"] = "SWITCH_NETWORK_UNSUPPORTED";
-    CheckoutErrorType["GET_ERC20_ALLOWANCE_ERROR"] = "GET_ERC20_ALLOWANCE_ERROR";
-    CheckoutErrorType["GET_ERC721_ALLOWANCE_ERROR"] = "GET_ERC721_ALLOWANCE_ERROR";
-    CheckoutErrorType["EXECUTE_APPROVAL_TRANSACTION_ERROR"] = "EXECUTE_APPROVAL_TRANSACTION_ERROR";
-    CheckoutErrorType["EXECUTE_FULFILLMENT_TRANSACTION_ERROR"] = "EXECUTE_FULFILLMENT_TRANSACTION_ERROR";
-    CheckoutErrorType["SIGN_MESSAGE_ERROR"] = "SIGN_MESSAGE_ERROR";
-    CheckoutErrorType["BRIDGE_GAS_ESTIMATE_ERROR"] = "BRIDGE_GAS_ESTIMATE_ERROR";
-    CheckoutErrorType["ORDER_FEE_ERROR"] = "ORDER_FEE_ERROR";
-    CheckoutErrorType["ITEM_REQUIREMENTS_ERROR"] = "ITEM_REQUIREMENTS_ERROR";
-    CheckoutErrorType["API_ERROR"] = "API_ERROR";
-    CheckoutErrorType["ORDER_EXPIRED_ERROR"] = "ORDER_EXPIRED_ERROR";
-    CheckoutErrorType["WIDGETS_SCRIPT_LOAD_ERROR"] = "WIDGETS_SCRIPT_LOAD_ERROR";
-})(CheckoutErrorType || (CheckoutErrorType = {}));
-/* The CheckoutError class is a custom error class in TypeScript that includes a message, type, and
-optional data object. */
-class CheckoutError extends Error {
-    message;
-    type;
-    data;
-    constructor(message, type, data) {
-        super(message);
-        this.message = message;
-        this.type = type;
-        this.data = data;
-    }
-}
-var CheckoutInternalErrorType;
-(function (CheckoutInternalErrorType) {
-    CheckoutInternalErrorType["REJECTED_SWITCH_AFTER_ADDING_NETWORK"] = "REJECTED_SWITCH_AFTER_ADDING_NETWORK";
-})(CheckoutInternalErrorType || (CheckoutInternalErrorType = {}));
-const withCheckoutError = async (
-/**
- * Wraps a function that returns a Promise and catches any errors that occur. If an error is caught,
- * it is wrapped in a CheckoutError and rethrown.
- */
-fn, customError) => {
-    try {
-        return await fn();
-    }
-    catch (error) {
-        const cause = `${error.message}` || 'UnknownError';
-        const errorMessage = customError.message
-            ? `[${customError.type}]:${customError.message}. Cause:${cause}`
-            : `[${customError.type}] Cause:${cause}`;
-        if (error instanceof CheckoutError) {
-            throw new CheckoutError(errorMessage, customError.type, {
-                ...customError.data,
-                innerErrorType: error.type,
-                ...error.data,
-            });
-        }
-        throw new CheckoutError(errorMessage, customError.type, {
-            ...customError.data,
-        });
-    }
+// 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: ethers.BigNumber.from(102e9),
+    maxPriorityFeePerGas: ethers.BigNumber.from(101e9),
 };
 
-// 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 providers.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 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;
@@ -30703,14 +30709,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;
     }
@@ -30826,6 +30832,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
 /**
@@ -31025,7 +31032,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) {
@@ -31066,6 +31073,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) {
@@ -31108,8 +31116,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 {
@@ -31295,11 +31302,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,
         };
@@ -31462,25 +31475,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, ethers.BigNumber.from(ethers.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 = ethers.BigNumber.from(swap.gasFeeEstimate.value);
-        }
         return {
             gasEstimateType: GasEstimateType.SWAP,
             gasFee: {
-                estimatedAmount,
+                estimatedAmount: swap.gasFeeEstimate.value ? ethers.BigNumber.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,
                 },
             },
         };
@@ -31871,7 +31880,7 @@ const getTokensFromRequirements = (itemRequirements) => itemRequirements
     .map((itemRequirement) => {
     if (itemRequirement.type === ItemType.NATIVE) {
         return {
-            address: IMX_ADDRESS_ZKEVM,
+            address: NATIVE,
         };
     }
     return {
@@ -31931,8 +31940,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
@@ -31960,7 +31968,6 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
                     name,
                     symbol,
                     decimals: DEFAULT_TOKEN_DECIMALS$1,
-                    address: IMX_ADDRESS_ZKEVM,
                 },
             };
         }
@@ -32019,9 +32026,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);
@@ -32427,7 +32438,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 {
@@ -32448,16 +32459,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 = ethers.BigNumber.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;
     }
@@ -32478,7 +32497,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
@@ -32496,7 +32516,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(ethers.BigNumber.from(0))) {
         feeMap.set(approvalFees.approvalGasTokenAddress, approvalFees.approvalGasFee);
     }
     // Add the swap gas fee to list of fees
@@ -32532,7 +32552,8 @@ const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFees, swapFe
     for (const [tokenAddress, fee] of feeMap.entries()) {
         if (fee === ethers.BigNumber.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;
         }
@@ -32584,9 +32605,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)
@@ -32683,7 +32704,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;
         }
     }
@@ -32739,25 +32760,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,
@@ -32844,16 +32868,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);
@@ -32871,12 +32888,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;
     }
@@ -32886,9 +32902,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);
         }
@@ -33044,8 +33060,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
@@ -33085,10 +33103,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
@@ -33277,7 +33292,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,
@@ -33513,8 +33528,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, {
@@ -33537,8 +33552,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, {
@@ -34114,10 +34129,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.
@@ -34470,7 +34481,7 @@ class Checkout {
     }
 }
 
-var checkout_sdk = /*#__PURE__*/Object.freeze({
+var checkout = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get BridgeEventType () { return BridgeEventType; },
     CHECKOUT_API_BASE_URL: CHECKOUT_API_BASE_URL,
@@ -34505,7 +34516,7 @@ var checkout_sdk = /*#__PURE__*/Object.freeze({
 });
 
 exports.blockchainData = blockchain_data;
-exports.checkoutSdk = checkout_sdk;
+exports.checkout = checkout;
 exports.config = config;
 exports.immutablexClient = immutablex_client;
 exports.orderbook = orderbook;