@imtbl/sdk 0.36.5 → 0.38.0

package/dist/index.cjs

@@ -61,7 +61,7 @@ class ImmutableConfiguration {
     }
 }
 const API_KEY_PREFIX = 'sk_imapik-';
-const PUBLISHABLE_KEY_PREFIX = 'pk_imapik-';
+const PUBLISHABLE_KEY_PREFIX$1 = 'pk_imapik-';
 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');
@@ -69,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)) {
+    if (!publishableKey.startsWith(PUBLISHABLE_KEY_PREFIX$1)) {
         throw new Error('Invalid Publishable key. Create your Publishable key in Immutable developer hub.'
             + ' https://hub.immutable.com');
     }
@@ -4256,7 +4256,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.36.5' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.38.0' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -4316,7 +4316,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.36.5',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.38.0',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4755,7 +4755,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.36.5',
+    sdkVersion: 'ts-immutable-sdk-0.38.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -12254,13 +12254,13 @@ var ProtocolData;
     })(ProtocolData.order_type || (ProtocolData.order_type = {}));
 })(ProtocolData || (ProtocolData = {}));
 
-var FeeType;
+var FeeType$1;
 (function (FeeType) {
     FeeType["MAKER_ECOSYSTEM"] = "MAKER_ECOSYSTEM";
     FeeType["TAKER_ECOSYSTEM"] = "TAKER_ECOSYSTEM";
     FeeType["PROTOCOL"] = "PROTOCOL";
     FeeType["ROYALTY"] = "ROYALTY";
-})(FeeType || (FeeType = {}));
+})(FeeType$1 || (FeeType$1 = {}));
 var TransactionPurpose;
 (function (TransactionPurpose) {
     TransactionPurpose["APPROVAL"] = "APPROVAL";
@@ -12822,7 +12822,7 @@ class ImmutableApiClient {
                 ],
                 fees: makerFees.map((x) => ({
                     amount: x.amount,
-                    type: FeeType.MAKER_ECOSYSTEM,
+                    type: FeeType$1.MAKER_ECOSYSTEM,
                     recipient_address: x.recipientAddress,
                 })),
                 end_at: new Date(parseInt(`${orderComponents.endTime.toString()}000`, 10)).toISOString(),
@@ -13036,7 +13036,7 @@ class Orderbook {
                 order_id: listingId,
                 fees: takerFees.map((fee) => ({
                     amount: fee.amount,
-                    type: FeeType.TAKER_ECOSYSTEM,
+                    type: FeeType$1.TAKER_ECOSYSTEM,
                     recipient_address: fee.recipientAddress,
                 })),
             },
@@ -13059,7 +13059,7 @@ class Orderbook {
             order_id: listingRequest.listingId,
             fees: listingRequest.takerFees.map((fee) => ({
                 amount: fee.amount,
-                type: FeeType.TAKER_ECOSYSTEM,
+                type: FeeType$1.TAKER_ECOSYSTEM,
                 recipient_address: fee.recipientAddress,
             })),
         })));
@@ -13190,7 +13190,7 @@ const constants = {
 var orderbook = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get ActionType () { return ActionType; },
-    get FeeType () { return FeeType; },
+    get FeeType () { return FeeType$1; },
     get OrderStatusName () { return OrderStatusName; },
     Orderbook: Orderbook,
     get SignablePurpose () { return SignablePurpose; },
@@ -34802,6 +34802,7 @@ var ConnectEventType;
     ConnectEventType["CLOSE_WIDGET"] = "close-widget";
     ConnectEventType["SUCCESS"] = "success";
     ConnectEventType["FAILURE"] = "failure";
+    ConnectEventType["LANGUAGE_CHANGED"] = "language-changed";
 })(ConnectEventType || (ConnectEventType = {}));
 
 /**
@@ -34812,6 +34813,7 @@ var WalletEventType;
     WalletEventType["CLOSE_WIDGET"] = "close-widget";
     WalletEventType["NETWORK_SWITCH"] = "network-switch";
     WalletEventType["DISCONNECT_WALLET"] = "disconnect-wallet";
+    WalletEventType["LANGUAGE_CHANGED"] = "language-changed";
 })(WalletEventType || (WalletEventType = {}));
 
 /**
@@ -34823,6 +34825,7 @@ var SwapEventType;
     SwapEventType["SUCCESS"] = "success";
     SwapEventType["FAILURE"] = "failure";
     SwapEventType["REJECTED"] = "rejected";
+    SwapEventType["LANGUAGE_CHANGED"] = "language-changed";
 })(SwapEventType || (SwapEventType = {}));
 
 /**
@@ -34835,6 +34838,7 @@ var SaleEventType;
     SaleEventType["FAILURE"] = "failure";
     SaleEventType["REJECTED"] = "rejected";
     SaleEventType["TRANSACTION_SUCCESS"] = "transaction-success";
+    SaleEventType["LANGUAGE_CHANGED"] = "language-changed";
 })(SaleEventType || (SaleEventType = {}));
 
 /**
@@ -34845,6 +34849,7 @@ var BridgeEventType;
     BridgeEventType["CLOSE_WIDGET"] = "close-widget";
     BridgeEventType["FAILURE"] = "failure";
     BridgeEventType["TRANSACTION_SENT"] = "transaction-sent";
+    BridgeEventType["LANGUAGE_CHANGED"] = "language-changed";
 })(BridgeEventType || (BridgeEventType = {}));
 
 /**
@@ -34867,6 +34872,7 @@ var OnRampEventType;
     OnRampEventType["CLOSE_WIDGET"] = "close-widget";
     OnRampEventType["SUCCESS"] = "success";
     OnRampEventType["FAILURE"] = "failure";
+    OnRampEventType["LANGUAGE_CHANGED"] = "language-changed";
 })(OnRampEventType || (OnRampEventType = {}));
 
 /**
@@ -35075,6 +35081,21 @@ var RoutingOutcomeType;
     RoutingOutcomeType["NO_ROUTES_FOUND"] = "NO_ROUTES_FOUND";
     RoutingOutcomeType["NO_ROUTE_OPTIONS"] = "NO_ROUTE_OPTIONS";
 })(RoutingOutcomeType || (RoutingOutcomeType = {}));
+/**
+ * An enum representing the funding step types
+ * @enum {string}
+ * @property {string} GAS - If the fee is a gas fee.
+ * @property {string} BRIDGE_FEE - If the fee is a bridge fee.
+ * @property {string} SWAP_FEE - If the fee is a swap fee.
+ * @property {string} IMMUTABLE_FEE - If the fee is an immutable fee.
+ */
+var FeeType;
+(function (FeeType) {
+    FeeType["GAS"] = "GAS";
+    FeeType["BRIDGE_FEE"] = "BRIDGE_FEE";
+    FeeType["SWAP_FEE"] = "SWAP_FEE";
+    FeeType["IMMUTABLE_FEE"] = "IMMUTABLE_FEE";
+})(FeeType || (FeeType = {}));
 /**
  * An enum representing the funding step types
  * @enum {string}
@@ -35680,32 +35701,21 @@ const GAS_OVERRIDES = {
     maxPriorityFeePerGas: ethers.BigNumber.from(101e9),
 };
 
-const SDK_VERSION_MARKER = '0.36.5';
+const SDK_VERSION_MARKER = '0.38.0';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
 class RemoteConfigFetcher {
+    httpClient;
     isDevelopment;
     isProduction;
     configCache;
     tokensCache;
     version = 'v1';
-    constructor(params) {
+    constructor(httpClient, params) {
         this.isDevelopment = params.isDevelopment;
         this.isProduction = params.isProduction;
-    }
-    static async makeHttpRequest(url) {
-        let response;
-        try {
-            response = await globalAxios$1.get(url);
-        }
-        catch (error) {
-            throw new CheckoutError(`Error fetching from api: ${error.message}`, CheckoutErrorType.API_ERROR);
-        }
-        if (response.status !== 200) {
-            throw new CheckoutError(`Error fetching from api: ${response.status} ${response.statusText}`, CheckoutErrorType.API_ERROR);
-        }
-        return response;
+        this.httpClient = httpClient;
     }
     getEndpoint = () => {
         if (this.isDevelopment)
@@ -35717,14 +35727,14 @@ class RemoteConfigFetcher {
     async loadConfig() {
         if (this.configCache)
             return this.configCache;
-        const response = await RemoteConfigFetcher.makeHttpRequest(`${this.getEndpoint()}/${this.version}/config`);
+        const response = await this.httpClient.get(`${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()}/${this.version}/config/tokens`);
+        const response = await this.httpClient.get(`${this.getEndpoint()}/${this.version}/config/tokens`);
         this.tokensCache = response.data;
         return this.tokensCache;
     }
@@ -35742,6 +35752,7 @@ class RemoteConfigFetcher {
             return {};
         return config[chainId] ?? [];
     }
+    getHttpClient = () => this.httpClient;
 }
 
 class CheckoutConfigurationError extends Error {
@@ -35792,7 +35803,7 @@ class CheckoutConfiguration {
     remote;
     environment;
     networkMap;
-    constructor(config) {
+    constructor(config, httpClient) {
         if (!Object.values(Environment$1).includes(config.baseConfig.environment)) {
             throw new CheckoutConfigurationError('Invalid checkout configuration of environment');
         }
@@ -35803,7 +35814,7 @@ class CheckoutConfiguration {
         this.isSwapEnabled = config.swap?.enable ?? DEFAULT_SWAP_ENABLED;
         this.isBridgeEnabled = config.bridge?.enable ?? DEFAULT_BRIDGE_ENABLED;
         this.networkMap = networkMap(this.isProduction, this.isDevelopment);
-        this.remote = new RemoteConfigFetcher({
+        this.remote = new RemoteConfigFetcher(httpClient, {
             isDevelopment: this.isDevelopment,
             isProduction: this.isProduction,
         });
@@ -35868,9 +35879,7 @@ class Blockscout {
     ttl;
     chainId;
     cacheMap;
-    static async makeHttpRequest(url) {
-        return globalAxios$1.get(url);
-    }
+    httpClient;
     setCache(key, data) {
         this.cacheMap[key] = { data, ttl: new Date().getTime() + this.ttl * 1000 };
     }
@@ -35882,11 +35891,13 @@ class Blockscout {
     }
     /**
      * Blockscout constructor
+     * @param httpClient Client used for http requests
      * @param chainId target chain
      * @param ttl cache TTL
      */
-    constructor(params) {
-        this.chainId = params.chainId;
+    constructor(httpClient, chainId, ttl) {
+        this.httpClient = httpClient;
+        this.chainId = chainId;
         this.url = BLOCKSCOUT_CHAIN_URL_MAP[this.chainId].url;
         const native = BLOCKSCOUT_CHAIN_URL_MAP[this.chainId].nativeToken;
         this.nativeToken = {
@@ -35896,7 +35907,7 @@ class Blockscout {
             symbol: native.symbol,
         };
         this.cacheMap = {};
-        this.ttl = params.ttl !== undefined ? params.ttl : CACHE_DATA_TTL;
+        this.ttl = ttl !== undefined ? ttl : CACHE_DATA_TTL;
     }
     /**
      * isChainSupported verifies if the chain is supported by Blockscout
@@ -35924,7 +35935,7 @@ class Blockscout {
             const cached = this.getCache(url);
             if (cached)
                 return Promise.resolve(cached);
-            const response = await Blockscout.makeHttpRequest(url);
+            const response = await this.httpClient.get(url);
             if (response.status >= 400) {
                 return Promise.reject({
                     code: response.status,
@@ -35965,7 +35976,7 @@ class Blockscout {
             const cached = this.getCache(url);
             if (cached)
                 return Promise.resolve(cached);
-            const response = await Blockscout.makeHttpRequest(url);
+            const response = await this.httpClient.get(url);
             if (response.status >= 400) {
                 return Promise.reject({
                     code: response.status,
@@ -36050,7 +36061,7 @@ const blockscoutClientMap = new Map();
 // This function is a utility function that can be used to reset the
 // blockscout map and therefore clear all the cache.
 const resetBlockscoutClientMap = () => blockscoutClientMap.clear();
-const getIndexerBalance = async (walletAddress, chainId, filterTokens) => {
+const getIndexerBalance = async (config, 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 !== undefined;
@@ -36058,7 +36069,8 @@ const getIndexerBalance = async (walletAddress, chainId, filterTokens) => {
     // Get blockscout client for the given chain
     let blockscoutClient = blockscoutClientMap.get(chainId);
     if (!blockscoutClient) {
-        blockscoutClient = new Blockscout({ chainId });
+        const httpClient = config.remote.getHttpClient();
+        blockscoutClient = new Blockscout(httpClient, chainId);
         blockscoutClientMap.set(chainId, blockscoutClient);
     }
     // Hold the items in an array for post-fetching processing
@@ -36193,7 +36205,7 @@ const getAllBalances = async (config, web3Provider, walletAddress, chainId) => {
         const isL1Chain = getL1ChainId(config) === chainId;
         if (!address)
             address = await web3Provider?.getSigner().getAddress();
-        return await measureAsyncExecution(config, `Time to fetch balances using blockscout for ${chainId}`, getIndexerBalance(address, chainId, isL1Chain ? tokens : undefined));
+        return await measureAsyncExecution(config, `Time to fetch balances using blockscout for ${chainId}`, getIndexerBalance(config, address, chainId, isL1Chain ? tokens : undefined));
     }
     if (!web3Provider) {
         throw new CheckoutError('indexer is disabled for this chain, you must provide a provider.', CheckoutErrorType.MISSING_PARAMS);
@@ -36574,8 +36586,8 @@ const erc20ItemAggregator = (itemRequirements) => {
             aggregatedItemRequirements.push(itemRequirement);
             return;
         }
-        const { contractAddress, spenderAddress, amount } = itemRequirement;
-        const key = `${contractAddress}${spenderAddress}`;
+        const { tokenAddress, spenderAddress, amount } = itemRequirement;
+        const key = `${tokenAddress}${spenderAddress}`;
         const aggregateItem = aggregatedMap.get(key);
         if (aggregateItem && aggregateItem.type === ItemType.ERC20) {
             aggregateItem.amount = ethers.BigNumber.from(aggregateItem.amount).add(amount);
@@ -36641,10 +36653,10 @@ const hasERC20Allowances = async (provider, ownerAddress, itemRequirements) => {
     for (const itemRequirement of itemRequirements) {
         if (itemRequirement.type !== ItemType.ERC20)
             continue;
-        const { contractAddress, spenderAddress } = itemRequirement;
-        const key = `${contractAddress}${spenderAddress}`;
+        const { tokenAddress, spenderAddress } = itemRequirement;
+        const key = `${tokenAddress}${spenderAddress}`;
         erc20s.set(key, itemRequirement);
-        allowancePromises.set(key, getERC20Allowance(provider, ownerAddress, contractAddress, spenderAddress));
+        allowancePromises.set(key, getERC20Allowance(provider, ownerAddress, tokenAddress, spenderAddress));
     }
     const allowances = await Promise.all(allowancePromises.values());
     const allowancePromiseIds = Array.from(allowancePromises.keys());
@@ -36663,8 +36675,8 @@ const hasERC20Allowances = async (provider, ownerAddress, itemRequirements) => {
             continue;
         }
         sufficient = false; // Set sufficient false on the root of the return object when an ERC20 is insufficient
-        const { contractAddress, spenderAddress } = itemRequirement;
-        const key = `${contractAddress}${spenderAddress}`;
+        const { tokenAddress, spenderAddress } = itemRequirement;
+        const key = `${tokenAddress}${spenderAddress}`;
         const delta = itemRequirement.amount.sub(allowances[index]);
         // Create maps for both the insufficient ERC20 data and the transaction promises using the same key so the results can be merged
         insufficientERC20s.set(key, {
@@ -36674,7 +36686,7 @@ const hasERC20Allowances = async (provider, ownerAddress, itemRequirements) => {
             itemRequirement,
             approvalTransaction: undefined,
         });
-        transactionPromises.set(key, getERC20ApprovalTransaction(provider, ownerAddress, contractAddress, spenderAddress, delta));
+        transactionPromises.set(key, getERC20ApprovalTransaction(provider, ownerAddress, tokenAddress, spenderAddress, delta));
     }
     // Resolves the approval transactions and merges them with the insufficient ERC20 data
     const transactions = await Promise.all(transactionPromises.values());
@@ -36859,8 +36871,8 @@ const erc20BalanceAggregator = (itemRequirements) => {
             aggregatedItemRequirements.push(itemRequirement);
             return;
         }
-        const { contractAddress, amount } = itemRequirement;
-        const key = `${contractAddress}`;
+        const { tokenAddress, amount } = itemRequirement;
+        const key = `${tokenAddress}`;
         const aggregateItem = aggregatedMap.get(key);
         if (aggregateItem && aggregateItem.type === ItemType.ERC20) {
             aggregateItem.amount = ethers.BigNumber.from(aggregateItem.amount).add(amount);
@@ -36893,14 +36905,21 @@ const balanceAggregator = (itemRequirements) => erc721BalanceAggregator(erc20Bal
 /* eslint-disable arrow-body-style */
 const getTokensFromRequirements = (itemRequirements) => itemRequirements
     .map((itemRequirement) => {
-    if (itemRequirement.type === ItemType.NATIVE) {
-        return {
-            address: NATIVE,
-        };
+    switch (itemRequirement.type) {
+        case ItemType.ERC20:
+            return {
+                address: itemRequirement.tokenAddress,
+            };
+        case ItemType.NATIVE:
+            return {
+                address: NATIVE,
+            };
+        case ItemType.ERC721:
+        default:
+            return {
+                address: itemRequirement.contractAddress,
+            };
     }
-    return {
-        address: itemRequirement.contractAddress,
-    };
 });
 /**
  * Gets the balance requirement with delta for an ERC721 requirement.
@@ -36950,7 +36969,7 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
     // Get the requirements related balance
     if (itemRequirement.type === ItemType.ERC20) {
         itemBalanceResult = balances.find((balance) => {
-            return balance.token?.address === itemRequirement.contractAddress;
+            return balance.token?.address === itemRequirement.tokenAddress;
         });
     }
     else if (itemRequirement.type === ItemType.NATIVE) {
@@ -37014,7 +37033,7 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
             token: {
                 name,
                 symbol,
-                address: itemRequirement.contractAddress,
+                address: itemRequirement.tokenAddress,
                 decimals,
             },
         };
@@ -37173,7 +37192,7 @@ const getGasItemRequirement = (gas, transactionOrGas) => {
     return {
         type: ItemType.ERC20,
         amount: gas,
-        contractAddress: transactionOrGas.gasToken.contractAddress,
+        tokenAddress: transactionOrGas.gasToken.tokenAddress,
         spenderAddress: '',
     };
 };
@@ -37396,36 +37415,37 @@ const quoteFetcher = async (config, chainId, walletAddress, requiredToken, swapp
     }
 };
 
-const constructFees$1 = (approvalGasFees, swapGasFees, swapFees) => {
+const constructFees$1 = (approvalGasFee, swapGasFee, swapFees) => {
     let approvalGasFeeAmount = ethers.BigNumber.from(0);
     let approvalGasFeeFormatted = '0';
     let approvalToken;
-    if (approvalGasFees) {
-        approvalGasFeeAmount = approvalGasFees.value;
-        approvalGasFeeFormatted = ethers.utils.formatUnits(approvalGasFees.value, approvalGasFees.token.decimals);
+    if (approvalGasFee) {
+        approvalGasFeeAmount = approvalGasFee.value;
+        approvalGasFeeFormatted = ethers.utils.formatUnits(approvalGasFee.value, approvalGasFee.token.decimals);
         approvalToken = {
-            name: approvalGasFees.token.name ?? '',
-            symbol: approvalGasFees.token.symbol ?? '',
-            address: approvalGasFees.token.address,
-            decimals: approvalGasFees.token.decimals,
+            name: approvalGasFee.token.name ?? '',
+            symbol: approvalGasFee.token.symbol ?? '',
+            address: approvalGasFee.token.address,
+            decimals: approvalGasFee.token.decimals,
         };
     }
     let swapGasFeeAmount = ethers.BigNumber.from(0);
     let swapGasFeeFormatted = '0';
     let swapGasToken;
-    if (swapGasFees) {
-        swapGasFeeAmount = swapGasFees.value;
-        swapGasFeeFormatted = ethers.utils.formatUnits(swapGasFees.value, swapGasFees.token.decimals);
+    if (swapGasFee) {
+        swapGasFeeAmount = swapGasFee.value;
+        swapGasFeeFormatted = ethers.utils.formatUnits(swapGasFee.value, swapGasFee.token.decimals);
         swapGasToken = {
-            name: swapGasFees.token.name ?? '',
-            symbol: swapGasFees.token.symbol ?? '',
-            address: swapGasFees.token.address,
-            decimals: swapGasFees.token.decimals,
+            name: swapGasFee.token.name ?? '',
+            symbol: swapGasFee.token.symbol ?? '',
+            address: swapGasFee.token.address,
+            decimals: swapGasFee.token.decimals,
         };
     }
     const fees = [];
     for (const swapFee of swapFees) {
         fees.push({
+            type: FeeType.SWAP_FEE,
             amount: swapFee.amount.value,
             formattedAmount: ethers.utils.formatUnits(swapFee.amount.value, swapFee.amount.token.decimals),
             token: {
@@ -37437,12 +37457,14 @@ const constructFees$1 = (approvalGasFees, swapGasFees, swapFees) => {
         });
     }
     return {
-        approvalGasFees: {
+        approvalGasFee: {
+            type: FeeType.GAS,
             amount: approvalGasFeeAmount,
             formattedAmount: approvalGasFeeFormatted,
             token: approvalToken,
         },
-        swapGasFees: {
+        swapGasFee: {
+            type: FeeType.GAS,
             amount: swapGasFeeAmount,
             formattedAmount: swapGasFeeFormatted,
             token: swapGasToken,
@@ -37527,7 +37549,7 @@ const checkUserCanCoverApprovalFees = (l2Balances, approval) => {
     // The user has enough to cover approval gas fees
     return { sufficient: true, approvalGasFee, approvalGasTokenAddress };
 };
-const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFees, swapFees, tokenBeingSwapped) => {
+const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFee, swapFees, tokenBeingSwapped) => {
     // Set up a map of token addresses to amounts for each of the swap fees
     const feeMap = new Map();
     // Add the approval fee to list of fees
@@ -37535,13 +37557,13 @@ const checkUserCanCoverSwapFees = (l2Balances, approvalFees, swapGasFees, swapFe
         feeMap.set(approvalFees.approvalGasTokenAddress, approvalFees.approvalGasFee);
     }
     // Add the swap gas fee to list of fees
-    if (swapGasFees) {
-        const fee = feeMap.get(swapGasFees.token.address);
+    if (swapGasFee) {
+        const fee = feeMap.get(swapGasFee.token.address);
         if (fee) {
-            feeMap.set(swapGasFees.token.address, fee.add(swapGasFees.value));
+            feeMap.set(swapGasFee.token.address, fee.add(swapGasFee.value));
         }
         else {
-            feeMap.set(swapGasFees.token.address, swapGasFees.value);
+            feeMap.set(swapGasFee.token.address, swapGasFee.value);
         }
     }
     // Add the token being swapped to list of fees to ensure the user can cover the fee + the token swap
@@ -37795,31 +37817,39 @@ const hasSufficientL1Eth = (tokenBalanceResult, totalFees) => {
     const balance = getEthBalance(tokenBalanceResult);
     return balance.gte(totalFees);
 };
-const constructFees = (bridgeGasFees, bridgeFee, imtblFee, approvalGasFees, token) => {
+const constructFees = (bridgeGasFee, bridgeFee, imtblFee, approvalGasFee, token) => {
     const bridgeFeeDecimals = token?.decimals ?? DEFAULT_TOKEN_DECIMALS$1;
+    const bridgeFees = [];
+    if (bridgeFee.gt(0)) {
+        bridgeFees.push({
+            type: FeeType.BRIDGE_FEE,
+            amount: bridgeFee,
+            formattedAmount: ethers.utils.formatUnits(bridgeFee, bridgeFeeDecimals),
+            token,
+        });
+    }
+    if (imtblFee.gt(0)) {
+        bridgeFees.push({
+            type: FeeType.IMMUTABLE_FEE,
+            amount: imtblFee,
+            formattedAmount: ethers.utils.formatUnits(imtblFee, bridgeFeeDecimals),
+            token,
+        });
+    }
     return {
-        approvalGasFees: {
-            amount: approvalGasFees,
-            formattedAmount: ethers.utils.formatUnits(approvalGasFees, DEFAULT_TOKEN_DECIMALS$1),
+        approvalGasFee: {
+            type: FeeType.GAS,
+            amount: approvalGasFee,
+            formattedAmount: ethers.utils.formatUnits(approvalGasFee, DEFAULT_TOKEN_DECIMALS$1),
             token,
         },
-        bridgeGasFees: {
-            amount: bridgeGasFees,
-            formattedAmount: ethers.utils.formatUnits(bridgeGasFees, DEFAULT_TOKEN_DECIMALS$1),
+        bridgeGasFee: {
+            type: FeeType.GAS,
+            amount: bridgeGasFee,
+            formattedAmount: ethers.utils.formatUnits(bridgeGasFee, DEFAULT_TOKEN_DECIMALS$1),
             token,
         },
-        bridgeFees: [
-            {
-                amount: bridgeFee,
-                formattedAmount: ethers.utils.formatUnits(bridgeFee, bridgeFeeDecimals),
-                token,
-            },
-            {
-                amount: imtblFee,
-                formattedAmount: ethers.utils.formatUnits(imtblFee, bridgeFeeDecimals),
-                token,
-            },
-        ],
+        bridgeFees,
     };
 };
 const constructBridgeFundingRoute = (chainId, balance, bridgeRequirement, itemType, fees) => ({
@@ -38678,13 +38708,13 @@ const calculateFees = (orderFees, weiAmount, decimals = 18) => {
     return calculateFeesResult;
 };
 
-const getItemRequirement = (type, contractAddress, amount, spenderAddress) => {
+const getItemRequirement = (type, tokenAddress, amount, spenderAddress) => {
     switch (type) {
         case ItemType.ERC20:
             return {
                 type,
                 amount,
-                contractAddress,
+                tokenAddress,
                 spenderAddress,
             };
         case ItemType.NATIVE:
@@ -38907,7 +38937,7 @@ const getBuyToken = (buyToken, decimals = 18) => {
     return {
         type: ItemType.ERC20,
         amount: bnAmount.toString(),
-        contractAddress: buyToken.contractAddress,
+        contractAddress: buyToken.tokenAddress,
     };
 };
 const sell = async (config, provider, orders) => {
@@ -38921,7 +38951,7 @@ const sell = async (config, provider, orders) => {
     let decimals = 18;
     if (buyToken.type === ItemType.ERC20) {
         // get this from the allowed list
-        const buyTokenContract = new ethers.Contract(buyToken.contractAddress, JSON.stringify(ERC20ABI), provider);
+        const buyTokenContract = new ethers.Contract(buyToken.tokenAddress, JSON.stringify(ERC20ABI), provider);
         decimals = await measureAsyncExecution(config, 'Time to get decimals of token contract for the buy token', buyTokenContract.decimals());
     }
     const buyTokenOrNative = getBuyToken(buyToken, decimals);
@@ -39073,8 +39103,8 @@ async function getItemRequirementsFromRequirements(provider, requirements) {
     const decimalPromises = [];
     requirements.forEach((itemRequirementParam) => {
         if (itemRequirementParam.type === ItemType.ERC20) {
-            const { contractAddress } = itemRequirementParam;
-            decimalPromises.push(getTokenContract(contractAddress, ERC20ABI, provider).decimals());
+            const { tokenAddress } = itemRequirementParam;
+            decimalPromises.push(getTokenContract(tokenAddress, ERC20ABI, provider).decimals());
         }
     });
     const decimals = await Promise.all(decimalPromises);
@@ -39168,6 +39198,90 @@ function loadUnresolved(version) {
     return { loaded: false, element: tag };
 }
 
+const PUBLISHABLE_KEY_PREFIX = 'pk_imapik-';
+const publishableKeyDomainAllowlist = [
+    'https://checkout-api.dev.immutable.com',
+    'https://checkout-api.sandbox.immutable.com',
+    'https://checkout-api.immutable.com',
+];
+class HttpClient {
+    config;
+    axiosInstance;
+    constructor(config) {
+        this.config = config;
+        this.axiosInstance = globalAxios$1.create();
+        this.setupInterceptors();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    shouldAddPublishableKey(url) {
+        // Check if the request is going to a whitelisted domain
+        return publishableKeyDomainAllowlist.some((domain) => url.startsWith(domain));
+    }
+    setupInterceptors() {
+        this.axiosInstance.interceptors.request.use((config) => {
+            const publishableKey = this.config?.baseConfig?.publishableKey;
+            if (publishableKey && this.shouldAddPublishableKey(config.url || '')) {
+                if (!publishableKey.startsWith(PUBLISHABLE_KEY_PREFIX)) {
+                    throw new Error('Invalid Publishable key. Create your Publishable key in Immutable developer hub.'
+                        + ' https://hub.immutable.com');
+                }
+                // Add publishable key header for whitelisted domains
+                // eslint-disable-next-line no-param-reassign
+                config.headers['x-immutable-publishable-key'] = publishableKey;
+            }
+            return config;
+        }, (error) => Promise.reject(error));
+    }
+    // eslint-disable-next-line class-methods-use-this
+    processResponse(response) {
+        if (response && response?.status !== 200) {
+            throw new CheckoutError(`Error: ${response.status} ${response.statusText}`, CheckoutErrorType.API_ERROR);
+        }
+    }
+    async request(config) {
+        let response;
+        try {
+            response = await this.axiosInstance.request(config);
+        }
+        catch (error) {
+            throw new CheckoutError(error.message, CheckoutErrorType.API_ERROR);
+        }
+        this.processResponse(response);
+        return response;
+    }
+    async get(url, config) {
+        const requestConfig = {
+            ...config,
+            url,
+        };
+        return await this.request(requestConfig);
+    }
+    async post(url, data, config) {
+        const requestConfig = {
+            ...config,
+            data,
+            url,
+        };
+        return await this.request(requestConfig);
+    }
+    async put(url, data, config) {
+        const requestConfig = {
+            ...config,
+            data,
+            url,
+        };
+        return await this.request(requestConfig);
+    }
+    async delete(url, data, config) {
+        const requestConfig = {
+            ...config,
+            data,
+            url,
+        };
+        return await this.request(requestConfig);
+    }
+}
+
 const SANDBOX_CONFIGURATION = {
     baseConfig: {
         environment: Environment$1.SANDBOX,
@@ -39178,6 +39292,7 @@ const WIDGETS_SCRIPT_TIMEOUT = 100;
 // Checkout SDK
 class Checkout {
     readOnlyProviders;
+    httpClient;
     config;
     fiatRampService;
     availability;
@@ -39187,7 +39302,8 @@ class Checkout {
      * @param {CheckoutModuleConfiguration} [config=SANDBOX_CONFIGURATION] - The configuration object for the CheckoutModule.
      */
     constructor(config = SANDBOX_CONFIGURATION) {
-        this.config = new CheckoutConfiguration(config);
+        this.httpClient = new HttpClient(config);
+        this.config = new CheckoutConfiguration(config, this.httpClient);
         this.fiatRampService = new FiatRampService(this.config);
         this.readOnlyProviders = new Map();
         this.availability = availabilityService(this.config.isDevelopment, this.config.isProduction);
@@ -39389,7 +39505,7 @@ class Checkout {
         try {
             itemRequirements = await getItemRequirementsFromRequirements(web3Provider, params.itemRequirements);
         }
-        catch {
+        catch (error) {
             throw new CheckoutError('Failed to map item requirements', CheckoutErrorType.ITEM_REQUIREMENTS_ERROR);
         }
         return await smartCheckout(this.config, web3Provider, itemRequirements, params.transactionOrGasAmount);
@@ -39470,6 +39586,7 @@ var checkout = /*#__PURE__*/Object.freeze({
     get ConnectEventType () { return ConnectEventType; },
     get ConnectTargetLayer () { return ConnectTargetLayer; },
     get ExchangeType () { return ExchangeType; },
+    get FeeType () { return FeeType; },
     get FundingStepType () { return FundingStepType; },
     get GasEstimateType () { return GasEstimateType; },
     get GasTokenType () { return GasTokenType; },