@imtbl/sdk 0.44.4 → 0.45.1

package/dist/index.cjs

@@ -16,14 +16,14 @@ var abi = require('@0xsequence/abi');
 var core = require('@0xsequence/core');
 var FormData$2 = require('form-data');
 var seaportJs = require('@opensea/seaport-js');
-var units = require('@ethersproject/units');
-var bignumber = require('@ethersproject/bignumber');
 var detectEthereumProvider = require('@metamask/detect-provider');
 var Uniswap = require('@uniswap/sdk-core');
 var assert = require('assert');
 var v3Sdk = require('@uniswap/v3-sdk');
 var solidity = require('@ethersproject/solidity');
 var routerSdk = require('@uniswap/router-sdk');
+var units = require('@ethersproject/units');
+var bignumber = require('@ethersproject/bignumber');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -10641,7 +10641,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.44.4' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.45.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -10713,7 +10713,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.44.4',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.45.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -11152,7 +11152,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.44.4',
+    sdkVersion: 'ts-immutable-sdk-0.45.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -11198,7 +11198,7 @@ class ImxConfiguration {
     }
 }
 
-class ImmutableXClient {
+class IMXClient {
     immutableX;
     depositsApi;
     mintsApi;
@@ -11655,14 +11655,6 @@ class ImmutableXClient {
     }
 }
 
-var immutablex_client = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    IMXError: coreSdk.IMXError,
-    ImmutableXClient: ImmutableXClient,
-    imxClientCreateStarkSigner: coreSdk.createStarkSigner,
-    imxClientGenerateLegacyStarkPrivateKey: coreSdk.generateLegacyStarkPrivateKey
-});
-
 function bind$1(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -17895,7 +17887,7 @@ class Passport {
         this.magicAdapter = new MagicAdapter(this.config);
         this.confirmationScreen = new ConfirmationScreen(this.config);
         this.immutableXClient = passportModuleConfiguration.overrides?.immutableXClient
-            || new ImmutableXClient({
+            || new IMXClient({
                 baseConfig: passportModuleConfiguration.baseConfig,
             });
         this.multiRollupApiClients = new MultiRollupApiClients(this.config.multiRollupConfig);
@@ -19645,1151 +19637,67 @@ var orderbook = /*#__PURE__*/Object.freeze({
     constants: constants
 });
 
-function isChainValid(chainID, config) {
-    return chainID === config.ethConfiguration.chainID;
-}
-async function validateChain(signer, config) {
-    const chainID = await signer.getChainId();
-    if (!isChainValid(chainID, config)) {
-        throw new Error('The wallet used for this operation is not connected to the correct network.');
-    }
+function bind(fn, thisArg) {
+  return function wrap() {
+    return fn.apply(thisArg, arguments);
+  };
 }
 
-async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
-    const transferAmount = request.type === 'ERC721' ? '1' : request.amount;
-    const signableResult = await transfersApi.getSignableTransferV1({
-        getSignableTransferRequest: {
-            sender: ethAddress,
-            token: convertToSignableToken(request),
-            amount: transferAmount,
-            receiver: request.receiver,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, ethSigner);
-    const starkSignature = await starkSigner.signMessage(payloadHash);
-    const transferSigningParams = {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        sender_stark_key: signableResult.data.sender_stark_key,
-        sender_vault_id: signableResult.data.sender_vault_id,
-        receiver_stark_key: signableResult.data.receiver_stark_key,
-        receiver_vault_id: signableResult.data.receiver_vault_id,
-        asset_id: signableResult.data.asset_id,
-        amount: signableResult.data.amount,
-        nonce: signableResult.data.nonce,
-        expiration_timestamp: signableResult.data.expiration_timestamp,
-        stark_signature: starkSignature,
-    };
-    const response = await transfersApi.createTransferV1({
-        createTransferRequest: transferSigningParams,
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return {
-        sent_signature: response?.data.sent_signature,
-        status: response?.data.status?.toString(),
-        time: response?.data.time,
-        transfer_id: response?.data.transfer_id,
-    };
-}
-async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
-    const signableRequests = request.map((nftTransfer) => ({
-        amount: '1',
-        token: convertToSignableToken({
-            type: 'ERC721',
-            tokenId: nftTransfer.tokenId,
-            tokenAddress: nftTransfer.tokenAddress,
-        }),
-        receiver: nftTransfer.receiver,
-    }));
-    const signableResult = await transfersApi.getSignableTransfer({
-        getSignableTransferRequestV2: {
-            sender_ether_key: ethAddress,
-            signable_requests: signableRequests,
-        },
-    });
-    const signableMessage = signableResult.data.signable_message;
-    if (signableMessage === undefined) {
-        throw new Error('Invalid response from Signable registration offchain');
-    }
-    const ethSignature = await signRaw(signableMessage, ethSigner);
-    const requests = [];
-    for (const resp of signableResult.data.signable_responses) {
-        // TODO: remove once fixed
-        // eslint-disable-next-line no-await-in-loop
-        const starkSignature = await starkSigner.signMessage(resp.payload_hash);
-        const req = {
-            sender_vault_id: resp.sender_vault_id,
-            receiver_stark_key: resp.receiver_stark_key,
-            receiver_vault_id: resp.receiver_vault_id,
-            asset_id: resp.asset_id,
-            amount: resp.amount,
-            nonce: resp.nonce,
-            expiration_timestamp: resp.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        requests.push(req);
-    }
-    // TODO: throw error on missing payload hash?
-    const transferSigningParams = {
-        sender_stark_key: signableResult.data.sender_stark_key,
-        requests,
-    };
-    const response = await transfersApi.createTransfer({
-        createTransferRequestV2: transferSigningParams,
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return {
-        transfer_ids: response?.data.transfer_ids,
-    };
-}
+// utils is a library of generic helper functions non-specific to axios
 
-async function createOrder({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
-    const amountSell = request.sell.type === 'ERC721' ? '1' : request.sell.amount;
-    const amountBuy = request.buy.type === 'ERC721' ? '1' : request.buy.amount;
-    const getSignableOrderRequest = {
-        user: ethAddress,
-        amount_buy: amountBuy,
-        token_buy: convertToSignableToken(request.buy),
-        amount_sell: amountSell,
-        token_sell: convertToSignableToken(request.sell),
-        fees: request.fees,
-        expiration_timestamp: request.expiration_timestamp,
-    };
-    const getSignableOrderResponse = await ordersApi.getSignableOrder({
-        getSignableOrderRequestV3: getSignableOrderRequest,
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableOrderResponse.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-    const resp = getSignableOrderResponse.data;
-    const orderParams = {
-        createOrderRequest: {
-            amount_buy: resp.amount_buy,
-            amount_sell: resp.amount_sell,
-            asset_id_buy: resp.asset_id_buy,
-            asset_id_sell: resp.asset_id_sell,
-            expiration_timestamp: resp.expiration_timestamp,
-            fees: request.fees,
-            nonce: resp.nonce,
-            stark_key: resp.stark_key,
-            stark_signature: starkSignature,
-            vault_id_buy: resp.vault_id_buy,
-            vault_id_sell: resp.vault_id_sell,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    };
-    const createOrderResponse = await ordersApi.createOrderV3(orderParams);
-    return {
-        ...createOrderResponse.data,
-    };
-}
-async function cancelOrder({ signers, request, config, }) {
-    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
-    const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3({
-        getSignableCancelOrderRequest: {
-            order_id: request.order_id,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const cancelOrderResponse = await ordersApi.cancelOrderV3({
-        id: request.order_id.toString(),
-        cancelOrderRequest: {
-            order_id: request.order_id,
-            stark_signature: starkSignature,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return {
-        order_id: cancelOrderResponse.data.order_id,
-        status: cancelOrderResponse.data.status,
-    };
-}
+const {toString} = Object.prototype;
+const {getPrototypeOf} = Object;
 
-async function registerOffchain(signers, config) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const usersApi = new coreSdk.UsersApi(config.immutableXConfig.apiConfiguration);
-    const userAddress = await signers.ethSigner.getAddress();
-    const starkPublicKey = await signers.starkSigner.getAddress();
-    const signableResult = await usersApi.getSignableRegistrationOffchain({
-        getSignableRegistrationRequest: {
-            ether_key: userAddress,
-            stark_key: starkPublicKey,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-    const registeredUser = await usersApi.registerUser({
-        registerUserRequest: {
-            eth_signature: ethSignature,
-            ether_key: userAddress,
-            stark_signature: starkSignature,
-            stark_key: starkPublicKey,
-        },
-    });
-    return registeredUser.data;
-}
-async function isRegisteredOffchain(ethAddress, config) {
-    try {
-        const usersApi = new coreSdk.UsersApi(config.immutableXConfig.apiConfiguration);
-        const getUsersResult = await usersApi.getUsers({
-            user: ethAddress,
-        });
-        const { accounts } = getUsersResult.data;
-        return accounts?.length > 0;
-    }
-    catch (ex) {
-        if (ex instanceof globalAxios$1.AxiosError && ex.response?.status === 404) {
-            return false;
-        }
-        throw ex;
-    }
-}
-async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const registrationContract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
-    try {
-        return await registrationContract.isRegistered(starkPublicKey);
-    }
-    catch (ex) {
-        if (ex.reason === 'USER_UNREGISTERED') {
-            return false;
-        }
-        throw ex;
-    }
-}
-async function getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi) {
-    const response = await usersApi.getSignableRegistration({
-        getSignableRegistrationRequest: {
-            ether_key: etherKey,
-            stark_key: starkPublicKey,
-        },
-    });
-    return {
-        operator_signature: response.data.operator_signature,
-        payload_hash: response.data.payload_hash,
-        readable_transaction: response.data.readable_transaction,
-        verification_signature: response.data.verification_signature,
-    };
-}
+const kindOf = (cache => thing => {
+    const str = toString.call(thing);
+    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+})(Object.create(null));
 
-const assertIsDefined = (value) => {
-    if (value !== undefined)
-        return value;
-    throw new Error('undefined field exception');
+const kindOfTest = (type) => {
+  type = type.toLowerCase();
+  return (thing) => kindOf(thing) === type
 };
-async function prepareWithdrawalAction(params) {
-    const { signers: { ethSigner, starkSigner }, type, config, } = params;
-    await validateChain(ethSigner, params.config);
-    const withdrawalsApi = new coreSdk.WithdrawalsApi(config.apiConfiguration);
-    const withdrawalAmount = type === 'ERC721' ? '1' : params.amount;
-    const signableWithdrawalResult = await withdrawalsApi.getSignableWithdrawal({
-        getSignableWithdrawalRequest: {
-            user: await ethSigner.getAddress(),
-            token: convertToSignableToken(params),
-            amount: withdrawalAmount,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableWithdrawalResult.data;
-    const starkSignature = await starkSigner.signMessage(payloadHash);
-    const { ethAddress, ethSignature } = await signMessage$1(signableMessage, ethSigner);
-    const prepareWithdrawalResponse = await withdrawalsApi.createWithdrawal({
-        createWithdrawalRequest: {
-            stark_key: assertIsDefined(signableWithdrawalResult.data.stark_key),
-            amount: withdrawalAmount,
-            asset_id: assertIsDefined(signableWithdrawalResult.data.asset_id),
-            vault_id: assertIsDefined(signableWithdrawalResult.data.vault_id),
-            nonce: assertIsDefined(signableWithdrawalResult.data.nonce),
-            stark_signature: starkSignature,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return prepareWithdrawalResponse.data;
-}
 
-async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
-    const encodingApi = new coreSdk.EncodingApi(config.apiConfiguration);
-    const result = await encodingApi.encodeAsset({
-        assetType,
-        encodeAssetRequest: {
-            token: {
-                type: tokenType,
-                ...(tokenData && { data: tokenData }),
-            },
-        },
-    });
-    return result.data;
-}
+const typeOfTest = type => thing => typeof thing === type;
 
-async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
-    const etherKey = await ethSigner.getAddress();
-    const imxConfig = config.immutableXConfig;
-    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ERC20', imxConfig, {
-        token_address: token.tokenAddress,
-    });
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawERC20({
-            ethSigner,
-            assetType: assetType.asset_type,
-            starkPublicKey,
-            config,
-        });
-    }
-    return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
-}
+/**
+ * Determine if a value is an Array
+ *
+ * @param {Object} val The value to test
+ *
+ * @returns {boolean} True if value is an Array, otherwise false
+ */
+const {isArray} = Array;
 
-async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdrawAndMint(starkPublicKey, assetType, mintingBlob);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.regsiterAndWithdrawAndMint(etherKey, starkPublicKey, signableResult.operator_signature, assetType, mintingBlob);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-function getMintingBlob(token) {
-    const { id } = token.data;
-    const blueprint = token.data.blueprint || '';
-    return encUtils__namespace.sanitizeHex(encUtils__namespace.utf8ToHex(`{${id}}:{${blueprint}}`));
-}
-async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', imxConfig, {
-        id: token.data.id,
-        token_address: token.data.tokenAddress,
-        ...(token.data.blueprint && { blueprint: token.data.blueprint }),
-    });
-    const mintingBlob = getMintingBlob(token);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
-    }
-    return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
-}
-async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdrawNft(etherKey, starkPublicKey, signableResult.operator_signature, assetType, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdrawNft(starkPublicKey, assetType, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ERC721', imxConfig, {
-        token_id: token.tokenId,
-        token_address: token.tokenAddress,
-    });
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
-    }
-    return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
-}
-async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const { tokenAddress } = token;
-    const { tokenId } = token;
-    const imxConfig = config.immutableXConfig;
-    const mintsApi = new coreSdk.MintsApi(imxConfig.apiConfiguration);
-    return await mintsApi
-        .getMintableTokenDetailsByClientTokenId({
-        tokenAddress,
-        tokenId,
-    })
-        .then((mintableToken) => completeMintableERC721Withdrawal(ethSigner, starkPublicKey, {
-        type: 'ERC721',
-        data: {
-            id: tokenId,
-            tokenAddress,
-            blueprint: mintableToken.data.blueprint,
-        },
-    }, config))
-        .catch((error) => {
-        if (error.response?.status === 404) {
-            // token is already minted on L1
-            return completeERC721Withdrawal(ethSigner, starkPublicKey, token, config);
-        }
-        throw error; // unable to recover from any other kind of error
-    });
-}
+/**
+ * Determine if a value is undefined
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if the value is undefined, otherwise false
+ */
+const isUndefined = typeOfTest('undefined');
 
-async function executeRegisterAndWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
-    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const imxConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ETH', imxConfig);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
-    }
-    return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+/**
+ * Determine if a value is a Buffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Buffer, otherwise false
+ */
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
+    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
 }
 
-async function prepareWithdrawal({ signers, withdrawal, config, }) {
-    return prepareWithdrawalAction({
-        signers,
-        config: config.immutableXConfig,
-        ...withdrawal,
-    });
-}
-// TODO: remove once fixed
-// eslint-disable-next-line consistent-return
-async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, token, config, }) {
-    // TODO: please add a reasonable default here
-    // eslint-disable-next-line default-case
-    switch (token.type) {
-        case 'ETH':
-            return completeEthWithdrawalAction({ ethSigner, starkPublicKey, config });
-        case 'ERC20':
-            return completeERC20WithdrawalAction({
-                ethSigner,
-                starkPublicKey,
-                token,
-                config,
-            });
-        case 'ERC721':
-            return completeERC721WithdrawalAction({
-                ethSigner,
-                starkPublicKey,
-                token,
-                config,
-            });
-    }
-}
-
-async function createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const ethAddress = await ethSigner.getAddress();
-    const tradesApi = new coreSdk.TradesApi(config.immutableXConfig.apiConfiguration);
-    const signableResult = await tradesApi.getSignableTrade({
-        getSignableTradeRequest: {
-            user: ethAddress,
-            order_id: request.order_id,
-            fees: request.fees,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, ethSigner);
-    const starkSignature = await starkSigner.signMessage(payloadHash);
-    const createTradeResponse = await tradesApi.createTradeV3({
-        createTradeRequest: {
-            amount_buy: signableResult.data.amount_buy,
-            amount_sell: signableResult.data.amount_sell,
-            asset_id_buy: signableResult.data.asset_id_buy,
-            asset_id_sell: signableResult.data.asset_id_sell,
-            expiration_timestamp: signableResult.data.expiration_timestamp,
-            fee_info: signableResult.data.fee_info,
-            fees: request.fees,
-            include_fees: true,
-            nonce: signableResult.data.nonce,
-            order_id: request.order_id,
-            stark_key: signableResult.data.stark_key,
-            vault_id_buy: signableResult.data.vault_id_buy,
-            vault_id_sell: signableResult.data.vault_id_sell,
-            stark_signature: starkSignature,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return createTradeResponse.data;
-}
-
-async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
-    const etherKey = await ethSigner.getAddress();
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
-}
-async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
-}
-async function depositEth({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const user = await ethSigner.getAddress();
-    const data = {
-        decimals: 18,
-    };
-    const amount = units.parseUnits(deposit.amount, 'wei');
-    const imxConfig = config.immutableXConfig;
-    const depositsApi = new coreSdk.DepositsApi(imxConfig.apiConfiguration);
-    const encodingApi = new coreSdk.EncodingApi(imxConfig.apiConfiguration);
-    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
-    }
-    return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
-}
-
-async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
-    const etherKey = await ethSigner.getAddress();
-    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
-    const user = await ethSigner.getAddress();
-    const tokensApi = new coreSdk.TokensApi(apiConfiguration);
-    const depositsApi = new coreSdk.DepositsApi(apiConfiguration);
-    const encodingApi = new coreSdk.EncodingApi(apiConfiguration);
-    const usersApi = new coreSdk.UsersApi(apiConfiguration);
-    // Get decimals for this specific ERC20
-    const token = await tokensApi.getToken({ address: deposit.tokenAddress });
-    // TODO: remove once fixed
-    // eslint-disable-next-line radix
-    const decimals = parseInt(token.data.decimals);
-    const data = {
-        decimals,
-        token_address: deposit.tokenAddress,
-    };
-    const amount = units.parseUnits(deposit.amount, 0); // 0 to always use undecimalized value
-    // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = coreSdk.Contracts.IERC20.connect(deposit.tokenAddress, ethSigner);
-    const approveTransaction = await tokenContract.populateTransaction.approve(ethConfiguration.coreContractAddress, amount);
-    await ethSigner.sendTransaction(approveTransaction);
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    // Perform encoding on asset details to get an assetType (required for stark contract request)
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-                data: {
-                    token_address: deposit.tokenAddress,
-                },
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const quantizedAmount = bignumber.BigNumber.from(signableDepositResult.data.amount);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration, usersApi);
-    }
-    return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
-}
-
-async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const user = await ethSigner.getAddress();
-    const { immutableXConfig } = config;
-    const depositsApi = new coreSdk.DepositsApi(immutableXConfig.apiConfiguration);
-    const encodingApi = new coreSdk.EncodingApi(immutableXConfig.apiConfiguration);
-    const usersApi = new coreSdk.UsersApi(immutableXConfig.apiConfiguration);
-    const data = {
-        token_address: deposit.tokenAddress,
-        token_id: deposit.tokenId,
-    };
-    const amount = '1';
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    // Perform encoding on asset details to get an assetType (required for stark contract request)
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-                data: {
-                    token_address: deposit.tokenAddress,
-                    token_id: deposit.tokenId,
-                },
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = coreSdk.Contracts.IERC721.connect(deposit.tokenAddress, ethSigner);
-    const operator = immutableXConfig.ethConfiguration.coreContractAddress;
-    const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
-    if (!isApprovedForAll) {
-        await tokenContract.setApprovalForAll(operator, true);
-    }
-    if (!isRegistered) {
-        const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
-        const coreContract = coreSdk.Contracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
-        // Note: proxy registration contract registerAndDepositNft method is not used as
-        // it currently fails erc721 transfer ownership check
-        await coreContract.registerUser(user, starkPublicKey, signableResult.operator_signature);
-    }
-    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, immutableXConfig);
-}
-
-// TODO: remove once fixed deposit variable shadowing
-// eslint-disable-next-line consistent-return, @typescript-eslint/no-shadow
-async function deposit({ signers, deposit, config }) {
-    // TODO: please add a reasonable default here
-    // eslint-disable-next-line default-case
-    switch (deposit.type) {
-        case 'ETH':
-            return depositEth({ signers, deposit, config });
-        case 'ERC20':
-            return depositERC20({ signers, deposit, config });
-        case 'ERC721':
-            return depositERC721({ signers, deposit, config });
-    }
-}
-
-async function exchangeTransfer({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const exchangeApi = new coreSdk.ExchangesApi(config.immutableXConfig.apiConfiguration);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const transferAmount = request.amount;
-    const signableResult = await exchangeApi.getExchangeSignableTransfer({
-        id: request.transactionID,
-        getSignableTransferRequest: {
-            sender: ethAddress,
-            token: convertToSignableToken(request),
-            amount: transferAmount,
-            receiver: request.receiver,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
-    const transferSigningParams = {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        sender_stark_key: signableResult.data.sender_stark_key,
-        sender_vault_id: signableResult.data.sender_vault_id,
-        receiver_stark_key: signableResult.data.receiver_stark_key,
-        receiver_vault_id: signableResult.data.receiver_vault_id,
-        asset_id: signableResult.data.asset_id,
-        amount: signableResult.data.amount,
-        nonce: signableResult.data.nonce,
-        expiration_timestamp: signableResult.data.expiration_timestamp,
-        stark_signature: starkSignature,
-    };
-    const response = await exchangeApi.createExchangeTransfer({
-        id: request.transactionID,
-        createTransferRequest: transferSigningParams,
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return {
-        sent_signature: response?.data.sent_signature,
-        status: response?.data.status?.toString(),
-        time: response?.data.time,
-        transfer_id: response?.data.transfer_id,
-    };
-}
-
-class GenericIMXProvider {
-    config;
-    signers;
-    constructor(config, ethSigner, starkSigner) {
-        this.config = config;
-        this.signers = { ethSigner, starkSigner };
-    }
-    async getAddress() {
-        return this.signers.ethSigner.getAddress();
-    }
-    async isRegisteredOffchain() {
-        const ethAddress = await this.getAddress();
-        return isRegisteredOffchain(ethAddress, this.config);
-    }
-    registerOffchain() {
-        return registerOffchain(this.signers, this.config);
-    }
-    batchNftTransfer(request) {
-        return batchTransfer({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    cancelOrder(request) {
-        return cancelOrder({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    completeWithdrawal(starkPublicKey, token) {
-        return completeWithdrawal({
-            config: this.config,
-            signers: this.signers,
-            token,
-            starkPublicKey,
-        });
-    }
-    createOrder(request) {
-        return createOrder({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    createTrade(request) {
-        return createTrade({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    deposit(tokenAmount) {
-        return deposit({
-            signers: this.signers,
-            deposit: tokenAmount,
-            config: this.config,
-        });
-    }
-    exchangeTransfer(request) {
-        return exchangeTransfer({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    async isRegisteredOnchain() {
-        const starkPublicKey = await this.signers.starkSigner.getAddress();
-        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
-    }
-    prepareWithdrawal(request) {
-        return prepareWithdrawal({
-            signers: this.signers,
-            withdrawal: request,
-            config: this.config,
-        });
-    }
-    transfer(request) {
-        return transfer({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-}
-
-const WALLET_ACTION = {
-    // TODO: remove once fixed - consider using an enum
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    SWITCH_CHAIN: 'wallet_switchEthereumChain',
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    CONNECT: 'eth_requestAccounts',
-};
-function isRequestableProvider(provider) {
-    return !!provider?.request;
-}
-async function connectProvider(provider, chainID) {
-    await provider.request({ method: WALLET_ACTION.CONNECT });
-    if (chainID) {
-        await provider.request({
-            method: WALLET_ACTION.SWITCH_CHAIN,
-            params: [{ chainId: `0x${chainID.toString(16)}` }],
-        });
-    }
-}
-
-const ERRORS = {
-    // TODO: remove once fixed - consider using something in line with the naming convention
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
-};
-async function connect$1({ chainID, }) {
-    const provider = (await detectEthereumProvider());
-    if (!isRequestableProvider(provider)) {
-        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
-    }
-    await connectProvider(provider, chainID);
-    // NOTE: if we want to listen to Metamask events in the future, we can add a
-    // listener here.
-    return new ethers.ethers.providers.Web3Provider(provider);
-}
-
-const COMMUNICATION_TYPE = 'message';
-var RequestEventType;
-(function (RequestEventType) {
-    RequestEventType["GET_CONNECTION_REQUEST"] = "GET_CONNECTION_REQUEST";
-    RequestEventType["CONNECT_WALLET_REQUEST"] = "CONNECT_WALLET_REQUEST";
-    RequestEventType["SIGN_MESSAGE_REQUEST"] = "SIGN_MESSAGE_REQUEST";
-    RequestEventType["DISCONNECT_WALLET_REQUEST"] = "DISCONNECT_WALLET_REQUEST";
-})(RequestEventType || (RequestEventType = {}));
-var ResponseEventType;
-(function (ResponseEventType) {
-    ResponseEventType["CONNECT_WALLET_RESPONSE"] = "CONNECT_WALLET_RESPONSE";
-    ResponseEventType["SIGN_MESSAGE_RESPONSE"] = "SIGN_MESSAGE_RESPONSE";
-    ResponseEventType["GET_CONNECTION_RESPONSE"] = "GET_CONNECTION_RESPONSE";
-    ResponseEventType["DISCONNECT_WALLET_RESPONSE"] = "DISCONNECT_WALLET_RESPONSE";
-})(ResponseEventType || (ResponseEventType = {}));
-
-function postRequestMessage(iframe, payload) {
-    if (iframe && iframe.contentWindow) {
-        iframe.contentWindow.postMessage(payload, new URL(iframe.src).origin);
-    }
-}
-
-function messageResponseListener(iframe, event, eventType, callback) {
-    if (iframe && event.source !== iframe.contentWindow) {
-        return;
-    }
-    const l2WalletMessage = event.data;
-    if (l2WalletMessage.type !== eventType) {
-        return;
-    }
-    callback(l2WalletMessage.details);
-}
-
-class ImxSigner {
-    publicAddress;
-    iframe;
-    constructor(publicAddress, iframe) {
-        this.publicAddress = publicAddress;
-        this.iframe = iframe;
-    }
-    getAddress() {
-        return this.publicAddress;
-    }
-    signMessage(rawMessage) {
-        return new Promise((resolve, reject) => {
-            const listener = (event) => {
-                messageResponseListener(this.iframe, event, ResponseEventType.SIGN_MESSAGE_RESPONSE, (messageDetails) => {
-                    window.removeEventListener(COMMUNICATION_TYPE, listener);
-                    if (!messageDetails.success) {
-                        reject(new Error(messageDetails.error?.message));
-                    }
-                    resolve(messageDetails.data.signedMessage);
-                });
-            };
-            window.addEventListener(COMMUNICATION_TYPE, listener);
-            postRequestMessage(this.iframe, {
-                type: RequestEventType.SIGN_MESSAGE_REQUEST,
-                details: { starkPublicKey: this.publicAddress, message: rawMessage },
-            });
-        });
-    }
-    getIFrame() {
-        return this.iframe;
-    }
-}
-
-const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
-const IMX_WALLET_IFRAME_HOSTS = {
-    [Environment$1.SANDBOX]: 'https://wallets.sandbox.immutable.com',
-    [Environment$1.PRODUCTION]: 'https://wallets.immutable.com',
-};
-const IMX_WALLET_IFRAME_STYLE = 'display: none;';
-function getIFrame() {
-    return document.querySelector(`iframe#${IMX_WALLET_IFRAME_ID}`);
-}
-async function setupIFrame(env) {
-    return new Promise((resolve) => {
-        const iframe = document.createElement('iframe');
-        iframe.setAttribute('id', IMX_WALLET_IFRAME_ID);
-        iframe.setAttribute('src', IMX_WALLET_IFRAME_HOSTS[env]);
-        iframe.setAttribute('style', IMX_WALLET_IFRAME_STYLE);
-        document.body.appendChild(iframe);
-        iframe.onload = () => resolve(iframe);
-    });
-}
-async function getOrSetupIFrame(env) {
-    const iframe = getIFrame();
-    if (iframe)
-        return iframe;
-    return await setupIFrame(env);
-}
-
-const DEFAULT_CONNECTION_MESSAGE = 'Only sign this request if you’ve initiated an action with Immutable X.';
-const CONNECTION_FAILED_ERROR = 'The L2 IMX Wallet connection has failed';
-async function connect(l1Provider, env) {
-    const l1Signer = l1Provider.getSigner();
-    const address = await l1Signer.getAddress();
-    const signature = await l1Signer.signMessage(DEFAULT_CONNECTION_MESSAGE);
-    const iframe = await getOrSetupIFrame(env);
-    return new Promise((resolve, reject) => {
-        const listener = (event) => {
-            messageResponseListener(iframe, event, ResponseEventType.CONNECT_WALLET_RESPONSE, (messageDetails) => {
-                window.removeEventListener(COMMUNICATION_TYPE, listener);
-                if (!messageDetails.success) {
-                    reject(new Error(CONNECTION_FAILED_ERROR));
-                }
-                resolve(new ImxSigner(messageDetails.data.starkPublicKey, iframe));
-            });
-        };
-        window.addEventListener(COMMUNICATION_TYPE, listener);
-        postRequestMessage(iframe, {
-            type: RequestEventType.CONNECT_WALLET_REQUEST,
-            details: { ethAddress: address, signature },
-        });
-    });
-}
-async function disconnect(imxSigner) {
-    const iframe = imxSigner.getIFrame();
-    return new Promise((resolve, reject) => {
-        const listener = (event) => {
-            messageResponseListener(iframe, event, ResponseEventType.DISCONNECT_WALLET_RESPONSE, (messageDetails) => {
-                window.removeEventListener(COMMUNICATION_TYPE, listener);
-                if (!messageDetails.success && messageDetails.error) {
-                    reject(messageDetails.error);
-                }
-                iframe.remove();
-                resolve();
-            });
-        };
-        window.addEventListener(COMMUNICATION_TYPE, listener);
-        postRequestMessage(iframe, {
-            type: RequestEventType.DISCONNECT_WALLET_REQUEST,
-            details: { starkPublicKey: imxSigner.getAddress() },
-        });
-    });
-}
-
-var ProviderErrorType;
-(function (ProviderErrorType) {
-    ProviderErrorType["PROVIDER_CONNECTION_ERROR"] = "PROVIDER_CONNECTION_ERROR";
-    ProviderErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
-})(ProviderErrorType || (ProviderErrorType = {}));
-class ProviderError extends Error {
-    type;
-    constructor(message, type) {
-        super(message);
-        this.type = type;
-    }
-}
-const withProviderError = async (fn, customError) => {
-    try {
-        return await fn();
-    }
-    catch (error) {
-        const errorMessage = customError.message || `${error.message}` || 'UnknownError';
-        throw new ProviderError(errorMessage, customError.type);
-    }
-};
-
-class MetaMaskIMXProvider extends GenericIMXProvider {
-    static imxSigner;
-    static async connect(config) {
-        return await withProviderError(async () => {
-            const metaMaskProvider = await connect$1({
-                chainID: config.immutableXConfig.ethConfiguration.chainID,
-            });
-            this.imxSigner = await connect(metaMaskProvider, config.baseConfig.environment);
-            return new MetaMaskIMXProvider(config, metaMaskProvider.getSigner(), this.imxSigner);
-        }, { type: ProviderErrorType.WALLET_CONNECTION_ERROR });
-    }
-    static async disconnect() {
-        if (!this.imxSigner) {
-            throw new ProviderError('Attempted to disconnect from the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
-        }
-        return withProviderError(async () => {
-            await disconnect(this.imxSigner);
-        }, { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
-    }
-    static async signMessage(message) {
-        if (!this.imxSigner) {
-            throw new ProviderError('Attempted to sign a message with the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
-        }
-        return withProviderError(async () => await this.imxSigner.signMessage(message), { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
-    }
-}
-
-class ProviderConfiguration {
-    immutableXConfig;
-    baseConfig;
-    constructor({ baseConfig, overrides }) {
-        this.baseConfig = baseConfig;
-        if (overrides) {
-            this.immutableXConfig = overrides.immutableXConfig;
-        }
-        else {
-            // TODO: remove once a sensible default is chosen
-            // eslint-disable-next-line default-case
-            switch (baseConfig.environment) {
-                case Environment$1.SANDBOX: {
-                    this.immutableXConfig = coreSdk.Config.SANDBOX;
-                    break;
-                }
-                case Environment$1.PRODUCTION: {
-                    this.immutableXConfig = coreSdk.Config.PRODUCTION;
-                    break;
-                }
-            }
-        }
-    }
-}
-
-var provider = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    GenericIMXProvider: GenericIMXProvider,
-    MetaMaskIMXProvider: MetaMaskIMXProvider,
-    ProviderConfiguration: ProviderConfiguration
-});
-
-function bind(fn, thisArg) {
-  return function wrap() {
-    return fn.apply(thisArg, arguments);
-  };
-}
-
-// utils is a library of generic helper functions non-specific to axios
-
-const {toString} = Object.prototype;
-const {getPrototypeOf} = Object;
-
-const kindOf = (cache => thing => {
-    const str = toString.call(thing);
-    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
-})(Object.create(null));
-
-const kindOfTest = (type) => {
-  type = type.toLowerCase();
-  return (thing) => kindOf(thing) === type
-};
-
-const typeOfTest = type => thing => typeof thing === type;
-
-/**
- * Determine if a value is an Array
- *
- * @param {Object} val The value to test
- *
- * @returns {boolean} True if value is an Array, otherwise false
- */
-const {isArray} = Array;
-
-/**
- * Determine if a value is undefined
- *
- * @param {*} val The value to test
- *
- * @returns {boolean} True if the value is undefined, otherwise false
- */
-const isUndefined = typeOfTest('undefined');
-
-/**
- * Determine if a value is a Buffer
- *
- * @param {*} val The value to test
- *
- * @returns {boolean} True if value is a Buffer, otherwise false
- */
-function isBuffer(val) {
-  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
-    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
-}
-
-/**
- * Determine if a value is an ArrayBuffer
- *
- * @param {*} val The value to test
- *
- * @returns {boolean} True if value is an ArrayBuffer, otherwise false
- */
-const isArrayBuffer = kindOfTest('ArrayBuffer');
+/**
+ * Determine if a value is an ArrayBuffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is an ArrayBuffer, otherwise false
+ */
+const isArrayBuffer = kindOfTest('ArrayBuffer');
 
 
 /**
@@ -41995,13 +40903,13 @@ const ERC721ABI = [
     },
 ];
 // 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),
+// https://docs.immutable.com/docs/zkEVM/architecture/gas-config
+const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
+    maxFeePerGas: ethers.BigNumber.from(15e9),
+    maxPriorityFeePerGas: ethers.BigNumber.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '0.44.4';
+const SDK_VERSION_MARKER = '0.45.1';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -42149,6 +41057,9 @@ class CheckoutConfiguration {
 }
 
 const isMatchingAddress = (addressA = '', addressB = '') => (addressA.toLowerCase() === addressB.toLowerCase());
+const isZkEvmChainId = (chainId) => chainId === ChainId.IMTBL_ZKEVM_DEVNET
+    || chainId === ChainId.IMTBL_ZKEVM_TESTNET
+    || chainId === ChainId.IMTBL_ZKEVM_MAINNET;
 
 const getTokenAllowList = async (config, { type = TokenFilterTypes.ALL, chainId, exclude, }) => {
     let tokens = [];
@@ -42495,7 +41406,7 @@ const getBalances = async (config, web3Provider, walletAddress, tokens) => {
     });
     return { balances };
 };
-const getAllBalances = async (config, web3Provider, walletAddress, chainId) => {
+const getAllBalances = async (config, web3Provider, walletAddress, chainId, forceFetch = false) => {
     if (!walletAddress && !web3Provider) {
         throw new CheckoutError('both walletAddress and provider are missing. At least one must be provided.', CheckoutErrorType.MISSING_PARAMS);
     }
@@ -42517,6 +41428,9 @@ const getAllBalances = async (config, web3Provider, walletAddress, chainId) => {
         // eslint-disable-next-line no-console
         console.error(err);
     }
+    if (forceFetch) {
+        resetBlockscoutClientMap();
+    }
     let address = walletAddress;
     if (flag && Blockscout.isChainSupported(chainId)) {
         // This is a hack because the widgets are still using the tokens symbol
@@ -42682,16 +41596,19 @@ async function getWalletAllowList(params) {
     };
 }
 
-const setTransactionGasLimits = (transaction) => {
+const setTransactionGasLimits = async (web3Provider, transaction) => {
     const rawTx = transaction;
-    rawTx.maxFeePerGas = GAS_OVERRIDES.maxFeePerGas;
-    rawTx.maxPriorityFeePerGas = GAS_OVERRIDES.maxPriorityFeePerGas;
+    const { chainId } = await web3Provider.getNetwork();
+    if (!isZkEvmChainId(chainId))
+        return rawTx;
+    rawTx.maxFeePerGas = IMMUTABLE_ZKVEM_GAS_OVERRIDES.maxFeePerGas;
+    rawTx.maxPriorityFeePerGas = IMMUTABLE_ZKVEM_GAS_OVERRIDES.maxPriorityFeePerGas;
     return rawTx;
 };
 const sendTransaction = async (web3Provider, transaction) => {
     try {
         const signer = web3Provider.getSigner();
-        const rawTx = setTransactionGasLimits(transaction);
+        const rawTx = await setTransactionGasLimits(web3Provider, transaction);
         const transactionResponse = await signer.sendTransaction(rawTx);
         return {
             transactionResponse,
@@ -43393,7 +42310,7 @@ const getTokenBalanceRequirement = (itemRequirement, balances) => {
 /**
  * Gets the balances for all NATIVE and ERC20 balance requirements.
  */
-const getTokenBalances = async (config, provider, ownerAddress, itemRequirements) => {
+const getTokenBalances = async (config, provider, ownerAddress, itemRequirements, forceFetch = false) => {
     try {
         const tokenMap = new Map();
         getTokensFromRequirements(itemRequirements).forEach((item) => {
@@ -43401,7 +42318,7 @@ const getTokenBalances = async (config, provider, ownerAddress, itemRequirements
                 return;
             tokenMap.set(item.address.toLocaleLowerCase(), item);
         });
-        const { balances } = await getAllBalances(config, provider, ownerAddress, getL2ChainId(config));
+        const { balances } = await getAllBalances(config, provider, ownerAddress, getL2ChainId(config), forceFetch);
         return balances.filter((balance) => tokenMap.get((balance.token.address || NATIVE).toLocaleLowerCase()));
     }
     catch (err) {
@@ -43451,7 +42368,7 @@ const getERC721Balances = async (provider, ownerAddress, itemRequirements) => {
 /**
  * Checks the item requirements against the owner balances.
  */
-const balanceCheck = async (config, provider, ownerAddress, itemRequirements) => {
+const balanceCheck = async (config, provider, ownerAddress, itemRequirements, forceFetch = false) => {
     const aggregatedItems = balanceAggregator(itemRequirements);
     const requiredToken = [];
     const requiredERC721 = [];
@@ -43472,7 +42389,7 @@ const balanceCheck = async (config, provider, ownerAddress, itemRequirements) =>
     // Get all ERC20 and NATIVE balances
     const balancePromises = [];
     if (requiredToken.length > 0) {
-        balancePromises.push(getTokenBalances(config, provider, ownerAddress, aggregatedItems));
+        balancePromises.push(getTokenBalances(config, provider, ownerAddress, aggregatedItems, forceFetch));
     }
     // Get all ERC721 balances
     if (requiredERC721.length > 0) {
@@ -44835,7 +43752,7 @@ const smartCheckout = async (config, provider, itemRequirements, transactionOrGa
         aggregatedItems.push(gasItem);
         aggregatedItems = itemAggregator(aggregatedItems);
     }
-    const balanceCheckResult = await measureAsyncExecution(config, 'Time to run balance checks', balanceCheck(config, provider, ownerAddress, aggregatedItems));
+    const balanceCheckResult = await measureAsyncExecution(config, 'Time to run balance checks', balanceCheck(config, provider, ownerAddress, aggregatedItems, true));
     const { sufficient } = balanceCheckResult;
     const transactionRequirements = balanceCheckResult.balanceRequirements;
     if (sufficient) {
@@ -44891,1099 +43808,2186 @@ const signFulfillmentTransactions = async (provider, fulfillmentTransactions) =>
         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, { error: err });
+        throw new CheckoutError('An error occurred while executing the fulfillment transaction', CheckoutErrorType.EXECUTE_FULFILLMENT_TRANSACTION_ERROR, { error: err });
+    }
+    for (const receipt of receipts) {
+        if (receipt.status === 0) {
+            return {
+                type: SignTransactionStatusType.FAILED,
+                transactionHash: receipt.transactionHash,
+                reason: 'Fulfillment transaction failed and was reverted',
+            };
+        }
+    }
+    return {
+        type: SignTransactionStatusType.SUCCESS,
+    };
+};
+const signMessage = async (provider, unsignedMessage) => {
+    try {
+        // eslint-disable-next-line no-underscore-dangle
+        const signedMessage = await provider.getSigner()._signTypedData(unsignedMessage.unsignedMessage.domain, unsignedMessage.unsignedMessage.types, unsignedMessage.unsignedMessage.value);
+        return {
+            orderComponents: unsignedMessage.orderComponents,
+            orderHash: unsignedMessage.orderHash,
+            signedMessage,
+        };
+    }
+    catch (err) {
+        throw new CheckoutError('An error occurred while signing the message', CheckoutErrorType.SIGN_MESSAGE_ERROR, { error: err });
+    }
+};
+
+const getUnsignedERC721Transactions = async (actions) => {
+    let approvalTransactions = [];
+    let fulfillmentTransactions = [];
+    const approvalPromises = [];
+    const fulfillmentPromises = [];
+    for (const action of actions) {
+        if (action.type !== ActionType.TRANSACTION)
+            continue;
+        if (action.purpose === TransactionPurpose.APPROVAL) {
+            approvalPromises.push(action.buildTransaction());
+        }
+        if (action.purpose === TransactionPurpose.FULFILL_ORDER) {
+            fulfillmentPromises.push(action.buildTransaction());
+        }
+    }
+    approvalTransactions = await Promise.all(approvalPromises);
+    fulfillmentTransactions = await Promise.all(fulfillmentPromises);
+    return {
+        approvalTransactions,
+        fulfillmentTransactions,
+    };
+};
+const getUnsignedERC20ApprovalTransactions = async (actions) => {
+    let approvalTransactions = [];
+    const approvalPromises = [];
+    for (const action of actions) {
+        if (action.type !== ActionType.TRANSACTION)
+            continue;
+        if (action.purpose === TransactionPurpose.APPROVAL) {
+            approvalPromises.push(action.buildTransaction());
+        }
+    }
+    approvalTransactions = await Promise.all(approvalPromises);
+    return approvalTransactions;
+};
+const getUnsignedFulfillmentTransactions = async (actions) => {
+    let fulfillmentTransactions = [];
+    const fulfillmentPromises = [];
+    for (const action of actions) {
+        if (action.type !== ActionType.TRANSACTION)
+            continue;
+        if (action.purpose === TransactionPurpose.FULFILL_ORDER) {
+            fulfillmentPromises.push(action.buildTransaction());
+        }
+    }
+    fulfillmentTransactions = await Promise.all(fulfillmentPromises);
+    return fulfillmentTransactions;
+};
+const getUnsignedMessage = (orderHash, orderComponents, actions) => {
+    let unsignedMessage;
+    for (const action of actions) {
+        if (action.type !== ActionType.SIGNABLE)
+            continue;
+        if (action.purpose === SignablePurpose.CREATE_LISTING) {
+            unsignedMessage = {
+                domain: action.message.domain,
+                types: action.message.types,
+                value: action.message.value,
+            };
+        }
+    }
+    if (!unsignedMessage)
+        return undefined;
+    return {
+        orderHash,
+        orderComponents,
+        unsignedMessage,
+    };
+};
+
+const MAX_FEE_PERCENTAGE_DECIMAL = 1; // 100%
+const MAX_FEE_DECIMAL_PLACES = 6; // will allow 0.000001 (0.0001%) as the minimum value
+const calculateFeesPercent = (orderFee, amountBn) => {
+    const feePercentage = orderFee.amount;
+    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
+    const feePercentageMultiplier = Math.round(feePercentage.percentageDecimal * (10 ** MAX_FEE_DECIMAL_PLACES));
+    const bnFeeAmount = amountBn
+        .mul(ethers.BigNumber.from(feePercentageMultiplier))
+        .div(10 ** MAX_FEE_DECIMAL_PLACES);
+    return bnFeeAmount;
+};
+const calculateFeesToken = (orderFee, decimals) => {
+    const feeToken = orderFee.amount;
+    const bnFeeAmount = ethers.utils.parseUnits(feeToken.token, decimals);
+    return bnFeeAmount;
+};
+const calculateFees = (orderFees, weiAmount, decimals = 18) => {
+    let totalTokenFees = ethers.BigNumber.from(0);
+    const amountBn = ethers.BigNumber.from(weiAmount);
+    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
+    const totalAllowableFees = amountBn
+        .mul(MAX_FEE_PERCENTAGE_DECIMAL * (10 ** MAX_FEE_DECIMAL_PLACES))
+        .div(10 ** MAX_FEE_DECIMAL_PLACES);
+    const calculateFeesResult = [];
+    for (const orderFee of orderFees) {
+        let currentFeeBn = ethers.BigNumber.from(0);
+        if (Object.hasOwn(orderFee.amount, 'percentageDecimal')) {
+            currentFeeBn = calculateFeesPercent(orderFee, amountBn);
+            totalTokenFees = totalTokenFees.add(currentFeeBn);
+        }
+        else if (Object.hasOwn(orderFee.amount, 'token')) {
+            currentFeeBn = calculateFeesToken(orderFee, decimals);
+            totalTokenFees = totalTokenFees.add(currentFeeBn);
+        }
+        else {
+            throw new CheckoutError('Unknown fee type parsed, must be percentageDecimal or token', CheckoutErrorType.ORDER_FEE_ERROR);
+        }
+        if (totalTokenFees.gt(totalAllowableFees)) {
+            throw new CheckoutError(`The combined fees are above the allowed maximum of ${MAX_FEE_PERCENTAGE_DECIMAL * 100}%`, CheckoutErrorType.ORDER_FEE_ERROR);
+        }
+        if (currentFeeBn.gt(0)) {
+            calculateFeesResult.push({
+                amount: currentFeeBn.toString(),
+                recipientAddress: orderFee.recipient,
+            });
+        }
+    } // for
+    return calculateFeesResult;
+};
+
+const getItemRequirement = (type, tokenAddress, amount, spenderAddress) => {
+    switch (type) {
+        case ItemType.ERC20:
+            return {
+                type,
+                amount,
+                tokenAddress,
+                spenderAddress,
+            };
+        case ItemType.NATIVE:
+        default:
+            return {
+                type: ItemType.NATIVE,
+                amount,
+            };
+    }
+};
+const getTransactionOrGas = (gasLimit, fulfillmentTransactions) => {
+    if (fulfillmentTransactions.length > 0) {
+        return {
+            type: TransactionOrGasType.TRANSACTION,
+            transaction: fulfillmentTransactions[0],
+        };
+    }
+    return {
+        type: TransactionOrGasType.GAS,
+        gasToken: {
+            type: GasTokenType.NATIVE,
+            limit: ethers.BigNumber.from(gasLimit),
+        },
+    };
+};
+const buy = async (config, provider, orders, overrides = {
+    waitFulfillmentSettlements: true,
+}) => {
+    if (orders.length === 0) {
+        throw new CheckoutError('No orders were provided to the orders array. Please provide at least one order.', CheckoutErrorType.FULFILL_ORDER_LISTING_ERROR);
+    }
+    let order;
+    let spenderAddress = '';
+    let decimals = 18;
+    const gasLimit = constants.estimatedFulfillmentGasGwei;
+    const orderbook = createOrderbookInstance(config);
+    const blockchainClient = createBlockchainDataInstance(config);
+    const fulfillerAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
+    // Prefetch balances and store them in memory
+    resetBlockscoutClientMap();
+    getAllBalances(config, provider, fulfillerAddress, getL1ChainId(config));
+    getAllBalances(config, provider, fulfillerAddress, getL2ChainId(config));
+    const { id, takerFees } = orders[0];
+    let orderChainName;
+    try {
+        order = await measureAsyncExecution(config, 'Time to fetch the listing from the orderbook', orderbook.getListing(id));
+        const { seaportContractAddress, chainName } = orderbook.config();
+        orderChainName = chainName;
+        spenderAddress = seaportContractAddress;
+    }
+    catch (err) {
+        throw new CheckoutError('An error occurred while getting the order listing', CheckoutErrorType.GET_ORDER_LISTING_ERROR, {
+            error: err,
+            orderId: id,
+        });
+    }
+    if (order.result.buy.length === 0) {
+        throw new CheckoutError('An error occurred with the get order listing', CheckoutErrorType.GET_ORDER_LISTING_ERROR, {
+            orderId: id,
+            message: 'No buy side tokens found on order',
+        });
+    }
+    const buyToken = order.result.buy[0];
+    if (buyToken.type === 'ERC20') {
+        const token = await measureAsyncExecution(config, 'Time to get decimals of token contract for the buy token', blockchainClient.getToken({ contractAddress: buyToken.contractAddress, chainName: orderChainName }));
+        if (token.result.decimals)
+            decimals = token.result.decimals;
+    }
+    let fees = [];
+    if (takerFees && takerFees.length > 0) {
+        fees = calculateFees(takerFees, buyToken.amount, decimals);
+    }
+    let unsignedApprovalTransactions = [];
+    let unsignedFulfillmentTransactions = [];
+    let orderActions = [];
+    const fulfillOrderStartTime = performance.now();
+    try {
+        const { actions } = await measureAsyncExecution(config, 'Time to call fulfillOrder from the orderbook', orderbook.fulfillOrder(id, fulfillerAddress, fees));
+        orderActions = actions;
+        unsignedApprovalTransactions = await measureAsyncExecution(config, 'Time to construct the unsigned approval transactions', getUnsignedERC20ApprovalTransactions(actions));
+    }
+    catch (err) {
+        const elapsedTimeInSeconds = (performance.now() - fulfillOrderStartTime) / 1000;
+        debugLogger(config, 'Time to call fulfillOrder from the orderbook', elapsedTimeInSeconds);
+        if (err.message.includes(OrderStatusName.EXPIRED)) {
+            throw new CheckoutError('Order is expired', CheckoutErrorType.ORDER_EXPIRED_ERROR, { orderId: id });
+        }
+        // The balances error will be handled by bulk order fulfillment but for now we
+        // need to assert on this string to check that the error is not a balances error
+        if (!err.message.includes('The fulfiller does not have the balances needed to fulfill')) {
+            throw new CheckoutError('Error occurred while trying to fulfill the order', CheckoutErrorType.FULFILL_ORDER_LISTING_ERROR, {
+                orderId: id,
+                error: err,
+            });
+        }
+    }
+    try {
+        unsignedFulfillmentTransactions = await measureAsyncExecution(config, 'Time to construct the unsigned fulfillment transactions', getUnsignedFulfillmentTransactions(orderActions));
+    }
+    catch {
+        // if cannot estimate gas then silently continue and use gas limit in smartCheckout
+        // but get the fulfillment transactions after they have approved the spending
+    }
+    let amount = ethers.BigNumber.from('0');
+    let type = ItemType.NATIVE;
+    let contractAddress = '';
+    const buyArray = order.result.buy;
+    if (buyArray.length > 0) {
+        switch (buyArray[0].type) {
+            case 'NATIVE':
+                type = ItemType.NATIVE;
+                break;
+            case 'ERC20':
+                type = ItemType.ERC20;
+                contractAddress = buyArray[0].contractAddress;
+                break;
+            default:
+                throw new CheckoutError('Purchasing token type is unsupported', CheckoutErrorType.UNSUPPORTED_TOKEN_TYPE_ERROR, {
+                    orderId: id,
+                });
+        }
+    }
+    buyArray.forEach((item) => {
+        if (item.type !== ItemType.ERC721) {
+            amount = amount.add(ethers.BigNumber.from(item.amount));
+        }
+    });
+    const feeArray = order.result.fees;
+    feeArray.forEach((item) => {
+        amount = amount.add(ethers.BigNumber.from(item.amount));
+    });
+    const itemRequirements = [
+        getItemRequirement(type, contractAddress, amount, spenderAddress),
+    ];
+    const smartCheckoutResult = await measureAsyncExecution(config, 'Total time running smart checkout', smartCheckout(config, provider, itemRequirements, getTransactionOrGas(gasLimit, unsignedFulfillmentTransactions)));
+    if (smartCheckoutResult.sufficient) {
+        const approvalResult = await signApprovalTransactions(provider, unsignedApprovalTransactions);
+        if (approvalResult.type === SignTransactionStatusType.FAILED) {
+            return {
+                status: CheckoutStatus.FAILED,
+                transactionHash: approvalResult.transactionHash,
+                reason: approvalResult.reason,
+                smartCheckoutResult,
+            };
+        }
+        try {
+            if (unsignedFulfillmentTransactions.length === 0) {
+                unsignedFulfillmentTransactions = await getUnsignedFulfillmentTransactions(orderActions);
+            }
+        }
+        catch (err) {
+            throw new CheckoutError('Error fetching fulfillment transaction', CheckoutErrorType.FULFILL_ORDER_LISTING_ERROR, { error: err });
+        }
+        if (overrides.waitFulfillmentSettlements) {
+            const fulfillmentResult = await signFulfillmentTransactions(provider, unsignedFulfillmentTransactions);
+            if (fulfillmentResult.type === SignTransactionStatusType.FAILED) {
+                return {
+                    status: CheckoutStatus.FAILED,
+                    transactionHash: fulfillmentResult.transactionHash,
+                    reason: fulfillmentResult.reason,
+                    smartCheckoutResult,
+                };
+            }
+            return {
+                status: CheckoutStatus.SUCCESS,
+                smartCheckoutResult,
+            };
+        }
+        let transactions;
+        try {
+            const response = await Promise.all(unsignedFulfillmentTransactions.map((transaction) => sendTransaction(provider, transaction)));
+            transactions = response.map((result) => result.transactionResponse);
+        }
+        catch (err) {
+            throw new CheckoutError('An error occurred while executing the fulfillment transaction', CheckoutErrorType.EXECUTE_FULFILLMENT_TRANSACTION_ERROR, {
+                message: err.message,
+            });
+        }
+        return {
+            status: CheckoutStatus.FULFILLMENTS_UNSETTLED,
+            smartCheckoutResult,
+            transactions,
+        };
+    }
+    return {
+        status: CheckoutStatus.INSUFFICIENT_FUNDS,
+        smartCheckoutResult,
+    };
+};
+
+const cancel = async (config, provider, orderIds, overrides = {
+    waitFulfillmentSettlements: true,
+}) => {
+    let unsignedCancelOrderTransaction;
+    if (orderIds.length === 0) {
+        throw new CheckoutError('No orderIds were provided to the orderIds array. Please provide at least one orderId.', CheckoutErrorType.CANCEL_ORDER_LISTING_ERROR);
+    }
+    // Update this when bulk cancel is supported
+    const orderId = orderIds[0];
+    try {
+        const offererAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
+        const orderbook = createOrderbookInstance(config);
+        const cancelOrderResponse = await measureAsyncExecution(config, 'Time to get the cancel order from the orderbook', orderbook.cancelOrdersOnChain([orderId], offererAddress));
+        unsignedCancelOrderTransaction = await cancelOrderResponse.cancellationAction.buildTransaction();
+    }
+    catch (err) {
+        throw new CheckoutError('An error occurred while cancelling the order listing', CheckoutErrorType.CANCEL_ORDER_LISTING_ERROR, {
+            orderId,
+            error: err,
+        });
+    }
+    if (overrides.waitFulfillmentSettlements) {
+        const result = await signFulfillmentTransactions(provider, [unsignedCancelOrderTransaction]);
+        if (result.type === SignTransactionStatusType.FAILED) {
+            return {
+                status: CheckoutStatus.FAILED,
+                transactionHash: result.transactionHash,
+                reason: result.reason,
+            };
+        }
+        return {
+            status: CheckoutStatus.SUCCESS,
+        };
+    }
+    let transactions;
+    try {
+        const response = await Promise.all([unsignedCancelOrderTransaction].map((transaction) => sendTransaction(provider, transaction)));
+        transactions = response.map((result) => result.transactionResponse);
+    }
+    catch (err) {
+        throw new CheckoutError('An error occurred while executing the fulfillment transaction', CheckoutErrorType.EXECUTE_FULFILLMENT_TRANSACTION_ERROR, {
+            message: err.message,
+        });
+    }
+    return {
+        status: CheckoutStatus.FULFILLMENTS_UNSETTLED,
+        transactions,
+    };
+};
+
+const getERC721Requirement = (id, contractAddress, spenderAddress) => ({
+    type: ItemType.ERC721,
+    id,
+    contractAddress,
+    spenderAddress,
+});
+const getBuyToken = (buyToken, decimals = 18) => {
+    const bnAmount = ethers.utils.parseUnits(buyToken.amount, decimals);
+    if (buyToken.type === ItemType.NATIVE) {
+        return {
+            type: ItemType.NATIVE,
+            amount: bnAmount.toString(),
+        };
+    }
+    return {
+        type: ItemType.ERC20,
+        amount: bnAmount.toString(),
+        contractAddress: buyToken.tokenAddress,
+    };
+};
+const sell = async (config, provider, orders) => {
+    let orderbook;
+    let listing;
+    let spenderAddress = '';
+    if (orders.length === 0) {
+        throw new CheckoutError('No orders were provided to the orders array. Please provide at least one order.', CheckoutErrorType.PREPARE_ORDER_LISTING_ERROR);
+    }
+    const { buyToken, sellToken, makerFees, orderExpiry, } = orders[0];
+    let decimals = 18;
+    if (buyToken.type === ItemType.ERC20) {
+        // get this from the allowed list
+        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);
+    try {
+        const walletAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
+        orderbook = createOrderbookInstance(config);
+        const { seaportContractAddress } = orderbook.config();
+        spenderAddress = seaportContractAddress;
+        listing = await measureAsyncExecution(config, 'Time to prepare the listing from the orderbook', orderbook.prepareListing({
+            makerAddress: walletAddress,
+            buy: buyTokenOrNative,
+            sell: {
+                type: ItemType.ERC721,
+                contractAddress: sellToken.collectionAddress,
+                tokenId: sellToken.id,
+            },
+            orderExpiry,
+        }));
+    }
+    catch (err) {
+        throw new CheckoutError('An error occurred while preparing the listing', CheckoutErrorType.PREPARE_ORDER_LISTING_ERROR, {
+            error: err,
+            id: sellToken.id,
+            collectionAddress: sellToken.collectionAddress,
+        });
     }
-    for (const receipt of receipts) {
-        if (receipt.status === 0) {
+    const itemRequirements = [
+        getERC721Requirement(sellToken.id, sellToken.collectionAddress, spenderAddress),
+    ];
+    const smartCheckoutResult = await measureAsyncExecution(config, 'Total time running smart checkout', smartCheckout(config, provider, itemRequirements, {
+        type: TransactionOrGasType.GAS,
+        gasToken: {
+            type: GasTokenType.NATIVE,
+            limit: ethers.BigNumber.from(constants.estimatedFulfillmentGasGwei),
+        },
+    }));
+    if (smartCheckoutResult.sufficient) {
+        const unsignedTransactions = await getUnsignedERC721Transactions(listing.actions);
+        const approvalResult = await signApprovalTransactions(provider, unsignedTransactions.approvalTransactions);
+        if (approvalResult.type === SignTransactionStatusType.FAILED) {
             return {
-                type: SignTransactionStatusType.FAILED,
-                transactionHash: receipt.transactionHash,
-                reason: 'Fulfillment transaction failed and was reverted',
+                status: CheckoutStatus.FAILED,
+                transactionHash: approvalResult.transactionHash,
+                reason: approvalResult.reason,
+                smartCheckoutResult,
             };
         }
-    }
-    return {
-        type: SignTransactionStatusType.SUCCESS,
-    };
-};
-const signMessage = async (provider, unsignedMessage) => {
-    try {
-        // eslint-disable-next-line no-underscore-dangle
-        const signedMessage = await provider.getSigner()._signTypedData(unsignedMessage.unsignedMessage.domain, unsignedMessage.unsignedMessage.types, unsignedMessage.unsignedMessage.value);
-        return {
-            orderComponents: unsignedMessage.orderComponents,
-            orderHash: unsignedMessage.orderHash,
-            signedMessage,
+        const unsignedMessage = getUnsignedMessage(listing.orderHash, listing.orderComponents, listing.actions);
+        if (!unsignedMessage) {
+            // For sell it is expected the orderbook will always return an unsigned message
+            // If for some reason it is missing then we cannot proceed with the create listing
+            throw new CheckoutError('The unsigned message is missing after preparing the listing', CheckoutErrorType.SIGN_MESSAGE_ERROR, {
+                id: sellToken.id,
+                collectionAddress: sellToken.collectionAddress,
+            });
+        }
+        const signedMessage = await signMessage(provider, unsignedMessage);
+        let orderId = '';
+        const createListingParams = {
+            orderComponents: signedMessage.orderComponents,
+            orderHash: signedMessage.orderHash,
+            orderSignature: signedMessage.signedMessage,
+            makerFees: [],
         };
-    }
-    catch (err) {
-        throw new CheckoutError('An error occurred while signing the message', CheckoutErrorType.SIGN_MESSAGE_ERROR, { error: err });
-    }
-};
-
-const getUnsignedERC721Transactions = async (actions) => {
-    let approvalTransactions = [];
-    let fulfillmentTransactions = [];
-    const approvalPromises = [];
-    const fulfillmentPromises = [];
-    for (const action of actions) {
-        if (action.type !== ActionType.TRANSACTION)
-            continue;
-        if (action.purpose === TransactionPurpose.APPROVAL) {
-            approvalPromises.push(action.buildTransaction());
+        if (makerFees !== undefined) {
+            const orderBookFees = calculateFees(makerFees, buyTokenOrNative.amount, decimals);
+            if (orderBookFees.length !== makerFees.length) {
+                throw new CheckoutError('One of the fees is too small, must be greater than 0.000001', CheckoutErrorType.CREATE_ORDER_LISTING_ERROR);
+            }
+            createListingParams.makerFees = orderBookFees;
         }
-        if (action.purpose === TransactionPurpose.FULFILL_ORDER) {
-            fulfillmentPromises.push(action.buildTransaction());
+        try {
+            const order = await orderbook.createListing(createListingParams);
+            orderId = order.result.id;
+        }
+        catch (err) {
+            throw new CheckoutError('An error occurred while creating the listing', CheckoutErrorType.CREATE_ORDER_LISTING_ERROR, {
+                error: err,
+                collectionId: sellToken.id,
+                collectionAddress: sellToken.collectionAddress,
+            });
         }
+        return {
+            status: CheckoutStatus.SUCCESS,
+            orderIds: [orderId],
+            smartCheckoutResult,
+        };
     }
-    approvalTransactions = await Promise.all(approvalPromises);
-    fulfillmentTransactions = await Promise.all(fulfillmentPromises);
     return {
-        approvalTransactions,
-        fulfillmentTransactions,
+        status: CheckoutStatus.INSUFFICIENT_FUNDS,
+        smartCheckoutResult,
     };
 };
-const getUnsignedERC20ApprovalTransactions = async (actions) => {
-    let approvalTransactions = [];
-    const approvalPromises = [];
-    for (const action of actions) {
-        if (action.type !== ActionType.TRANSACTION)
-            continue;
-        if (action.purpose === TransactionPurpose.APPROVAL) {
-            approvalPromises.push(action.buildTransaction());
-        }
+
+class FiatRampService {
+    config;
+    /**
+     * Constructs a new instance of the FiatRampService class.
+     * @param {CheckoutConfiguration} config - The config required for the FiatRampService.
+     */
+    constructor(config) {
+        this.config = config;
     }
-    approvalTransactions = await Promise.all(approvalPromises);
-    return approvalTransactions;
-};
-const getUnsignedFulfillmentTransactions = async (actions) => {
-    let fulfillmentTransactions = [];
-    const fulfillmentPromises = [];
-    for (const action of actions) {
-        if (action.type !== ActionType.TRANSACTION)
-            continue;
-        if (action.purpose === TransactionPurpose.FULFILL_ORDER) {
-            fulfillmentPromises.push(action.buildTransaction());
-        }
+    async feeEstimate() {
+        const config = (await this.config.remote.getConfig('onramp'));
+        return config[OnRampProvider.TRANSAK]?.fees;
     }
-    fulfillmentTransactions = await Promise.all(fulfillmentPromises);
-    return fulfillmentTransactions;
-};
-const getUnsignedMessage = (orderHash, orderComponents, actions) => {
-    let unsignedMessage;
-    for (const action of actions) {
-        if (action.type !== ActionType.SIGNABLE)
-            continue;
-        if (action.purpose === SignablePurpose.CREATE_LISTING) {
-            unsignedMessage = {
-                domain: action.message.domain,
-                types: action.message.types,
-                value: action.message.value,
-            };
-        }
+    async createWidgetUrl(params) {
+        return (await this.getTransakWidgetUrl(params));
     }
-    if (!unsignedMessage)
-        return undefined;
-    return {
-        orderHash,
-        orderComponents,
-        unsignedMessage,
-    };
-};
-
-const MAX_FEE_PERCENTAGE_DECIMAL = 1; // 100%
-const MAX_FEE_DECIMAL_PLACES = 6; // will allow 0.000001 (0.0001%) as the minimum value
-const calculateFeesPercent = (orderFee, amountBn) => {
-    const feePercentage = orderFee.amount;
-    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
-    const feePercentageMultiplier = Math.round(feePercentage.percentageDecimal * (10 ** MAX_FEE_DECIMAL_PLACES));
-    const bnFeeAmount = amountBn
-        .mul(ethers.BigNumber.from(feePercentageMultiplier))
-        .div(10 ** MAX_FEE_DECIMAL_PLACES);
-    return bnFeeAmount;
-};
-const calculateFeesToken = (orderFee, decimals) => {
-    const feeToken = orderFee.amount;
-    const bnFeeAmount = ethers.utils.parseUnits(feeToken.token, decimals);
-    return bnFeeAmount;
-};
-const calculateFees = (orderFees, weiAmount, decimals = 18) => {
-    let totalTokenFees = ethers.BigNumber.from(0);
-    const amountBn = ethers.BigNumber.from(weiAmount);
-    // note: multiply in and out of the maximum decimal places to the power of ten to do the math in big number integers
-    const totalAllowableFees = amountBn
-        .mul(MAX_FEE_PERCENTAGE_DECIMAL * (10 ** MAX_FEE_DECIMAL_PLACES))
-        .div(10 ** MAX_FEE_DECIMAL_PLACES);
-    const calculateFeesResult = [];
-    for (const orderFee of orderFees) {
-        let currentFeeBn = ethers.BigNumber.from(0);
-        if (Object.hasOwn(orderFee.amount, 'percentageDecimal')) {
-            currentFeeBn = calculateFeesPercent(orderFee, amountBn);
-            totalTokenFees = totalTokenFees.add(currentFeeBn);
+    async getTransakWidgetUrl(params) {
+        let widgetUrl = `${TRANSAK_API_BASE_URL[this.config.environment]}?`;
+        const onRampConfig = (await this.config.remote.getConfig('onramp'));
+        const apiKey = onRampConfig[OnRampProvider.TRANSAK].publishableApiKey;
+        const transakPublishableKey = `apiKey=${apiKey}`;
+        const zkevmNetwork = 'network=immutablezkevm';
+        const defaultPaymentMethod = 'defaultPaymentMethod=credit_debit_card';
+        const disableBankTransfer = 'disablePaymentMethods=sepa_bank_transfer,gbp_bank_transfer,'
+            + 'pm_cash_app,pm_jwire,pm_paymaya,pm_bpi,pm_ubp,pm_grabpay,pm_shopeepay,pm_gcash,pm_pix,'
+            + 'pm_astropay,pm_pse,inr_bank_transfer';
+        const productsAvailed = 'productsAvailed=buy';
+        const exchangeScreenTitle = 'exchangeScreenTitle=Buy';
+        const themeColor = 'themeColor=0D0D0D';
+        widgetUrl += `${transakPublishableKey}&`
+            + `${zkevmNetwork}&`
+            + `${defaultPaymentMethod}&`
+            + `${disableBankTransfer}&`
+            + `${productsAvailed}&`
+            + `${exchangeScreenTitle}&`
+            + `${themeColor}`;
+        if (params.isPassport && params.email) {
+            const encodedEmail = encodeURIComponent(params.email);
+            widgetUrl += `&email=${encodedEmail}&isAutoFillUserData=true&disableWalletAddressForm=true`;
         }
-        else if (Object.hasOwn(orderFee.amount, 'token')) {
-            currentFeeBn = calculateFeesToken(orderFee, decimals);
-            totalTokenFees = totalTokenFees.add(currentFeeBn);
+        if (params.tokenAmount && params.tokenSymbol) {
+            widgetUrl += `&defaultCryptoAmount=${params.tokenAmount}&cryptoCurrencyCode=${params.tokenSymbol}`;
         }
         else {
-            throw new CheckoutError('Unknown fee type parsed, must be percentageDecimal or token', CheckoutErrorType.ORDER_FEE_ERROR);
-        }
-        if (totalTokenFees.gt(totalAllowableFees)) {
-            throw new CheckoutError(`The combined fees are above the allowed maximum of ${MAX_FEE_PERCENTAGE_DECIMAL * 100}%`, CheckoutErrorType.ORDER_FEE_ERROR);
+            widgetUrl += '&defaultCryptoCurrency=IMX';
         }
-        if (currentFeeBn.gt(0)) {
-            calculateFeesResult.push({
-                amount: currentFeeBn.toString(),
-                recipientAddress: orderFee.recipient,
-            });
+        if (params.walletAddress) {
+            widgetUrl += `&walletAddress=${params.walletAddress}`;
         }
-    } // for
-    return calculateFeesResult;
-};
+        return widgetUrl;
+    }
+}
 
-const getItemRequirement = (type, tokenAddress, amount, spenderAddress) => {
-    switch (type) {
-        case ItemType.ERC20:
+async function getItemRequirementsFromRequirements(provider, requirements) {
+    // Get all decimal values by calling contracts for each ERC20
+    const decimalPromises = [];
+    requirements.forEach((itemRequirementParam) => {
+        if (itemRequirementParam.type === ItemType.ERC20) {
+            const { tokenAddress } = itemRequirementParam;
+            decimalPromises.push(getTokenContract(tokenAddress, ERC20ABI, provider).decimals());
+        }
+    });
+    const decimals = await Promise.all(decimalPromises);
+    // Map ItemRequirementsParam objects to ItemRequirement by parsing amounts from formatted string to BigNumebrs
+    const itemRequirements = requirements.map((itemRequirementParam, index) => {
+        if (itemRequirementParam.type === ItemType.NATIVE) {
             return {
-                type,
-                amount,
-                tokenAddress,
-                spenderAddress,
+                ...itemRequirementParam,
+                amount: ethers.utils.parseUnits(itemRequirementParam.amount, 18),
             };
-        case ItemType.NATIVE:
-        default:
+        }
+        if (itemRequirementParam.type === ItemType.ERC20) {
             return {
-                type: ItemType.NATIVE,
-                amount,
+                ...itemRequirementParam,
+                amount: ethers.utils.parseUnits(itemRequirementParam.amount, decimals[index]),
             };
+        }
+        return itemRequirementParam;
+    });
+    return itemRequirements;
+}
+
+/**
+ * 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.
+ * If the version is all zeros, it also returns the default checkout version.
+ * Otherwise, it constructs a validated version string based on the major, minor, patch, and build numbers.
+ */
+function validateAndBuildVersion(version) {
+    const defaultPackageVersion = globalPackageVersion();
+    if (version === undefined || version.major === undefined)
+        return defaultPackageVersion;
+    if (!Number.isInteger(version.major) || version.major < 0)
+        return defaultPackageVersion;
+    if (version.minor !== undefined && version.minor < 0)
+        return defaultPackageVersion;
+    if (version.patch !== undefined && version.patch < 0)
+        return defaultPackageVersion;
+    if (version.major === 0 && version.minor === undefined)
+        return defaultPackageVersion;
+    if (version.major === 0 && version.minor === 0 && version.patch === undefined)
+        return defaultPackageVersion;
+    if (version.major === 0 && version.minor === undefined && version.patch === undefined)
+        return defaultPackageVersion;
+    if (version.major === 0 && version.minor === 0 && version.patch === 0)
+        return defaultPackageVersion;
+    let validatedVersion = version.major.toString();
+    if (version.minor === undefined)
+        return validatedVersion;
+    if (Number.isInteger(version.minor)) {
+        validatedVersion += `.${version.minor.toString()}`;
     }
-};
-const getTransactionOrGas = (gasLimit, fulfillmentTransactions) => {
-    if (fulfillmentTransactions.length > 0) {
-        return {
-            type: TransactionOrGasType.TRANSACTION,
-            transaction: fulfillmentTransactions[0],
+    if (version.patch === undefined)
+        return validatedVersion;
+    if (Number.isInteger(version.patch)) {
+        validatedVersion += `.${version.patch.toString()}`;
+    }
+    if (version.prerelease === undefined || version.prerelease !== 'alpha')
+        return validatedVersion;
+    if (version.prerelease === 'alpha') {
+        validatedVersion += `-${version.prerelease}`;
+    }
+    if (version.build === undefined)
+        return validatedVersion;
+    if (Number.isInteger(version.build) && version.build >= 0) {
+        validatedVersion += `.${version.build.toString()}`;
+    }
+    return validatedVersion;
+}
+
+function loadUnresolved(version) {
+    if (window === undefined) {
+        throw new Error('missing window object: please run Checkout client side');
+    }
+    if (document === undefined) {
+        throw new Error('missing document object: please run Checkout client side');
+    }
+    const scriptId = 'immutable-checkout-widgets-bundle';
+    const validVersion = validateAndBuildVersion(version);
+    // Prevent the script to be loaded more than once
+    // by checking the presence of the script and its version.
+    const initScript = document.getElementById(scriptId);
+    if (initScript)
+        return { loaded: true, element: initScript };
+    const tag = document.createElement('script');
+    let cdnUrl = `https://cdn.jsdelivr.net/npm/@imtbl/sdk@${validVersion}/dist/browser/checkout/widgets.js`;
+    tag.setAttribute('id', scriptId);
+    tag.setAttribute('data-version', validVersion);
+    tag.setAttribute('src', cdnUrl);
+    document.head.appendChild(tag);
+    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));
+    }
+    async request(config) {
+        return await this.axiosInstance.request(config);
+    }
+    async get(url, config) {
+        const requestConfig = {
+            ...config,
+            url,
         };
+        return await this.request(requestConfig);
     }
-    return {
-        type: TransactionOrGasType.GAS,
-        gasToken: {
-            type: GasTokenType.NATIVE,
-            limit: ethers.BigNumber.from(gasLimit),
-        },
-    };
+    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,
+    },
+    passport: undefined,
 };
-const buy = async (config, provider, orders, overrides = {
-    waitFulfillmentSettlements: true,
-}) => {
-    if (orders.length === 0) {
-        throw new CheckoutError('No orders were provided to the orders array. Please provide at least one order.', CheckoutErrorType.FULFILL_ORDER_LISTING_ERROR);
+const WIDGETS_SCRIPT_TIMEOUT = 100;
+// Checkout SDK
+class Checkout {
+    readOnlyProviders;
+    httpClient;
+    config;
+    fiatRampService;
+    availability;
+    passport;
+    /**
+     * Constructs a new instance of the CheckoutModule class.
+     * @param {CheckoutModuleConfiguration} [config=SANDBOX_CONFIGURATION] - The configuration object for the CheckoutModule.
+     */
+    constructor(config = SANDBOX_CONFIGURATION) {
+        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);
+        this.passport = config.passport;
+    }
+    /**
+     * Loads the widgets bundle and initiate the widgets factory.
+     * @param {WidgetsInit} init - The initialisation parameters for loading the widgets bundle and applying configuration
+     */
+    async widgets(init) {
+        const checkout = this;
+        // Preload the configurations
+        await checkout.config.remote.getConfig();
+        const factory = new Promise((resolve, reject) => {
+            function checkForWidgetsBundleLoaded() {
+                if (typeof ImmutableCheckoutWidgets !== 'undefined') {
+                    resolve(new ImmutableCheckoutWidgets.WidgetsFactory(checkout, init.config));
+                }
+                else {
+                    // If ImmutableCheckoutWidgets is not defined, wait for set amount of time.
+                    // When time has elapsed, check again if ImmutableCheckoutWidgets is defined.
+                    // Once it's defined, the promise will resolve and setTimeout won't be called again.
+                    setTimeout(checkForWidgetsBundleLoaded, WIDGETS_SCRIPT_TIMEOUT);
+                }
+            }
+            try {
+                const script = loadUnresolved(init.version);
+                if (script.loaded && typeof ImmutableCheckoutWidgets !== 'undefined') {
+                    resolve(new ImmutableCheckoutWidgets.WidgetsFactory(checkout, init.config));
+                }
+                else {
+                    checkForWidgetsBundleLoaded();
+                }
+            }
+            catch (err) {
+                reject(new CheckoutError('Failed to load widgets script', CheckoutErrorType.WIDGETS_SCRIPT_LOAD_ERROR, { error: err }));
+            }
+        });
+        return factory;
+    }
+    /**
+     * Creates a provider using the given parameters.
+     * @param {CreateProviderParams} params - The parameters for creating the provider.
+     * @returns {Promise<CreateProviderResult>} A promise that resolves to the created provider.
+     */
+    async createProvider(params) {
+        return await createProvider(params.walletProviderName, this.passport);
+    }
+    /**
+     * Checks if a wallet is connected to the specified provider.
+     * @param {CheckConnectionParams} params - The parameters for checking the wallet connection.
+     * @returns {Promise<CheckConnectionResult>} - A promise that resolves to the result of the check.
+     */
+    async checkIsWalletConnected(params) {
+        const web3Provider = await validateProvider(this.config, params.provider, { allowUnsupportedProvider: true });
+        return checkIsWalletConnected(web3Provider);
     }
-    let order;
-    let spenderAddress = '';
-    let decimals = 18;
-    const gasLimit = constants.estimatedFulfillmentGasGwei;
-    const orderbook = createOrderbookInstance(config);
-    const blockchainClient = createBlockchainDataInstance(config);
-    const fulfillerAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
-    // Prefetch balances and store them in memory
-    resetBlockscoutClientMap();
-    getAllBalances(config, provider, fulfillerAddress, getL1ChainId(config));
-    getAllBalances(config, provider, fulfillerAddress, getL2ChainId(config));
-    const { id, takerFees } = orders[0];
-    let orderChainName;
-    try {
-        order = await measureAsyncExecution(config, 'Time to fetch the listing from the orderbook', orderbook.getListing(id));
-        const { seaportContractAddress, chainName } = orderbook.config();
-        orderChainName = chainName;
-        spenderAddress = seaportContractAddress;
+    /**
+     * Connects to a blockchain network using the specified provider.
+     * @param {ConnectParams} params - The parameters for connecting to the network.
+     * @returns {Promise<ConnectResult>} A promise that resolves to an object containing the provider and network information.
+     * @throws {Error} If the provider is not valid or if there is an error connecting to the network.
+     */
+    async connect(params) {
+        const web3Provider = await validateProvider(this.config, params.provider, { allowUnsupportedProvider: true });
+        await connectSite(web3Provider);
+        return { provider: web3Provider };
     }
-    catch (err) {
-        throw new CheckoutError('An error occurred while getting the order listing', CheckoutErrorType.GET_ORDER_LISTING_ERROR, {
-            error: err,
-            orderId: id,
+    /**
+     * Switches the network for the current wallet provider.
+     * @param {SwitchNetworkParams} params - The parameters for switching the network.
+     * @returns {Promise<SwitchNetworkResult>} - A promise that resolves to the result of switching the network.
+     */
+    async switchNetwork(params) {
+        const web3Provider = await validateProvider(this.config, params.provider, {
+            allowUnsupportedProvider: true,
+            allowMistmatchedChainId: true,
         });
+        const switchNetworkRes = await switchWalletNetwork(this.config, web3Provider, params.chainId);
+        return switchNetworkRes;
     }
-    if (order.result.buy.length === 0) {
-        throw new CheckoutError('An error occurred with the get order listing', CheckoutErrorType.GET_ORDER_LISTING_ERROR, {
-            orderId: id,
-            message: 'No buy side tokens found on order',
-        });
+    /**
+     * Retrieves the token information given the token address. This function makes RPC calls to
+     * ERC20 contracts to fetch the main contract information (e.g. symbol).
+     * @param {GetTokenInfoParams} params - The parameters for retrieving the token information.
+     * @returns {Promise<TokenInfo>} - A promise that resolves to the token info request.
+     */
+    async getTokenInfo(params) {
+        return await getERC20TokenInfo(params.provider, params.tokenAddress);
     }
-    const buyToken = order.result.buy[0];
-    if (buyToken.type === 'ERC20') {
-        const token = await measureAsyncExecution(config, 'Time to get decimals of token contract for the buy token', blockchainClient.getToken({ contractAddress: buyToken.contractAddress, chainName: orderChainName }));
-        if (token.result.decimals)
-            decimals = token.result.decimals;
+    /**
+     * Retrieves the balance of a wallet address.
+     * @param {GetBalanceParams} params - The parameters for retrieving the balance.
+     * @returns {Promise<GetBalanceResult>} - A promise that resolves to the balance result.
+     */
+    async getBalance(params) {
+        const web3Provider = await validateProvider(this.config, params.provider);
+        if (!params.tokenAddress || params.tokenAddress === '') {
+            return await getBalance(this.config, web3Provider, params.walletAddress);
+        }
+        return await getERC20Balance(web3Provider, params.walletAddress, params.tokenAddress);
     }
-    let fees = [];
-    if (takerFees && takerFees.length > 0) {
-        fees = calculateFees(takerFees, buyToken.amount, decimals);
+    /**
+     * Retrieves the balances of all tokens for a given wallet address on a specific chain.
+     * @param {GetAllBalancesParams} params - The parameters for retrieving the balances.
+     * @returns {Promise<GetAllBalancesResult>} - A promise that resolves to the result of retrieving the balances.
+     */
+    async getAllBalances(params) {
+        return getAllBalances(this.config, params.provider, params.walletAddress, params.chainId);
     }
-    let unsignedApprovalTransactions = [];
-    let unsignedFulfillmentTransactions = [];
-    let orderActions = [];
-    const fulfillOrderStartTime = performance.now();
-    try {
-        const { actions } = await measureAsyncExecution(config, 'Time to call fulfillOrder from the orderbook', orderbook.fulfillOrder(id, fulfillerAddress, fees));
-        orderActions = actions;
-        unsignedApprovalTransactions = await measureAsyncExecution(config, 'Time to construct the unsigned approval transactions', getUnsignedERC20ApprovalTransactions(actions));
+    /**
+     * Retrieves the supported networks based on the provided parameters.
+     * @param {GetNetworkAllowListParams} params - The parameters for retrieving the network allow list.
+     * @returns {Promise<GetNetworkAllowListResult>} - A promise that resolves to the network allow list result.
+     */
+    async getNetworkAllowList(params) {
+        return await getNetworkAllowList(this.config, params);
     }
-    catch (err) {
-        const elapsedTimeInSeconds = (performance.now() - fulfillOrderStartTime) / 1000;
-        debugLogger(config, 'Time to call fulfillOrder from the orderbook', elapsedTimeInSeconds);
-        if (err.message.includes(OrderStatusName.EXPIRED)) {
-            throw new CheckoutError('Order is expired', CheckoutErrorType.ORDER_EXPIRED_ERROR, { orderId: id });
-        }
-        // The balances error will be handled by bulk order fulfillment but for now we
-        // need to assert on this string to check that the error is not a balances error
-        if (!err.message.includes('The fulfiller does not have the balances needed to fulfill')) {
-            throw new CheckoutError('Error occurred while trying to fulfill the order', CheckoutErrorType.FULFILL_ORDER_LISTING_ERROR, {
-                orderId: id,
-                error: err,
-            });
-        }
+    /**
+     * Retrieves the supported tokens based on the provided parameters.
+     * @param {GetTokenAllowListParams} params - The parameters for retrieving the token allow list.
+     * @returns {Promise<GetTokenAllowListResult>} - A promise that resolves to the token allow list result.
+     */
+    async getTokenAllowList(params) {
+        return await getTokenAllowList(this.config, params);
     }
-    try {
-        unsignedFulfillmentTransactions = await measureAsyncExecution(config, 'Time to construct the unsigned fulfillment transactions', getUnsignedFulfillmentTransactions(orderActions));
+    /**
+     * Retrieves the default supported wallets based on the provided parameters.
+     * @param {GetWalletAllowListParams} params - The parameters for retrieving the wallet allow list.
+     * @returns {Promise<GetWalletAllowListResult>} - A promise that resolves to the wallet allow list result.
+     */
+    async getWalletAllowList(params) {
+        return await getWalletAllowList(params);
     }
-    catch {
-        // if cannot estimate gas then silently continue and use gas limit in smartCheckout
-        // but get the fulfillment transactions after they have approved the spending
+    /**
+     * Sends a transaction using the specified provider and transaction parameters.
+     * @param {SendTransactionParams} params - The parameters for sending the transaction.
+     * @returns {Promise<SendTransactionResult>} A promise that resolves to the result of the transaction.
+     */
+    async sendTransaction(params) {
+        const web3Provider = await validateProvider(this.config, params.provider);
+        return await sendTransaction(web3Provider, params.transaction);
     }
-    let amount = ethers.BigNumber.from('0');
-    let type = ItemType.NATIVE;
-    let contractAddress = '';
-    const buyArray = order.result.buy;
-    if (buyArray.length > 0) {
-        switch (buyArray[0].type) {
-            case 'NATIVE':
-                type = ItemType.NATIVE;
-                break;
-            case 'ERC20':
-                type = ItemType.ERC20;
-                contractAddress = buyArray[0].contractAddress;
-                break;
-            default:
-                throw new CheckoutError('Purchasing token type is unsupported', CheckoutErrorType.UNSUPPORTED_TOKEN_TYPE_ERROR, {
-                    orderId: id,
-                });
-        }
+    /**
+     * Retrieves network information using the specified provider.
+     * @param {GetNetworkParams} params - The parameters for retrieving network information.
+     * @returns {Promise<NetworkInfo>} A promise that resolves to the network information.
+     */
+    async getNetworkInfo(params) {
+        const web3Provider = await validateProvider(this.config, params.provider, {
+            allowUnsupportedProvider: true,
+            allowMistmatchedChainId: true,
+        });
+        return await getNetworkInfo(this.config, web3Provider);
     }
-    buyArray.forEach((item) => {
-        if (item.type !== ItemType.ERC721) {
-            amount = amount.add(ethers.BigNumber.from(item.amount));
+    /**
+     * Determines the requirements for performing a buy.
+     * @param {BuyParams} params - The parameters for the buy.
+    */
+    async buy(params) {
+        if (params.orders.length > 1) {
+            // eslint-disable-next-line no-console
+            console.warn('This endpoint currently only processes the first order in the array.');
         }
-    });
-    const feeArray = order.result.fees;
-    feeArray.forEach((item) => {
-        amount = amount.add(ethers.BigNumber.from(item.amount));
-    });
-    const itemRequirements = [
-        getItemRequirement(type, contractAddress, amount, spenderAddress),
-    ];
-    const smartCheckoutResult = await measureAsyncExecution(config, 'Total time running smart checkout', smartCheckout(config, provider, itemRequirements, getTransactionOrGas(gasLimit, unsignedFulfillmentTransactions)));
-    if (smartCheckoutResult.sufficient) {
-        const approvalResult = await signApprovalTransactions(provider, unsignedApprovalTransactions);
-        if (approvalResult.type === SignTransactionStatusType.FAILED) {
-            return {
-                status: CheckoutStatus.FAILED,
-                transactionHash: approvalResult.transactionHash,
-                reason: approvalResult.reason,
-                smartCheckoutResult,
-            };
+        const web3Provider = await validateProvider(this.config, params.provider);
+        return await buy(this.config, web3Provider, params.orders, params.overrides);
+    }
+    /**
+     * Determines the requirements for performing a sell.
+     * @param {SellParams} params - The parameters for the sell.
+     * Only currently actions the first order in the array until we support batch processing.
+     * Only currently actions the first fee in the fees array of each order until we support multiple fees.
+    */
+    async sell(params) {
+        if (params.orders.length > 1) {
+            // eslint-disable-next-line no-console
+            console.warn('This endpoint currently only processes the first order in the array.');
         }
+        const web3Provider = await validateProvider(this.config, params.provider);
+        return await sell(this.config, web3Provider, params.orders);
+    }
+    /**
+     * Cancels a sell.
+     * @param {CancelParams} params - The parameters for the cancel.
+     */
+    async cancel(params) {
+        // eslint-disable-next-line no-console
+        console.warn('This endpoint currently only processes the first order in the array.');
+        const web3Provider = await validateProvider(this.config, params.provider);
+        return await cancel(this.config, web3Provider, params.orderIds, params.overrides);
+    }
+    /**
+     * Determines the transaction requirements to complete a purchase.
+     * @params {SmartCheckoutParams} params - The parameters for smart checkout.
+     */
+    async smartCheckout(params) {
+        const web3Provider = await validateProvider(this.config, params.provider);
+        let itemRequirements = [];
         try {
-            if (unsignedFulfillmentTransactions.length === 0) {
-                unsignedFulfillmentTransactions = await getUnsignedFulfillmentTransactions(orderActions);
-            }
+            itemRequirements = await getItemRequirementsFromRequirements(web3Provider, params.itemRequirements);
         }
         catch (err) {
-            throw new CheckoutError('Error fetching fulfillment transaction', CheckoutErrorType.FULFILL_ORDER_LISTING_ERROR, { error: err });
-        }
-        if (overrides.waitFulfillmentSettlements) {
-            const fulfillmentResult = await signFulfillmentTransactions(provider, unsignedFulfillmentTransactions);
-            if (fulfillmentResult.type === SignTransactionStatusType.FAILED) {
-                return {
-                    status: CheckoutStatus.FAILED,
-                    transactionHash: fulfillmentResult.transactionHash,
-                    reason: fulfillmentResult.reason,
-                    smartCheckoutResult,
-                };
-            }
-            return {
-                status: CheckoutStatus.SUCCESS,
-                smartCheckoutResult,
-            };
+            throw new CheckoutError('Failed to map item requirements', CheckoutErrorType.ITEM_REQUIREMENTS_ERROR, { error: err });
         }
-        let transactions;
-        try {
-            const response = await Promise.all(unsignedFulfillmentTransactions.map((transaction) => sendTransaction(provider, transaction)));
-            transactions = response.map((result) => result.transactionResponse);
+        return await smartCheckout(this.config, web3Provider, itemRequirements, params.transactionOrGasAmount);
+    }
+    /**
+     * Checks if the given object is a Web3 provider.
+     * @param {Web3Provider} web3Provider - The object to check.
+     * @returns {boolean} - True if the object is a Web3 provider, false otherwise.
+     */
+    static isWeb3Provider(web3Provider) {
+        return isWeb3Provider(web3Provider);
+    }
+    /**
+     * Estimates the gas required for a swap or bridge transaction.
+     * @param {GasEstimateParams} params - The parameters for the gas estimation.
+     * @returns {Promise<GasEstimateSwapResult | GasEstimateBridgeToL2Result>} - A promise that resolves to the gas estimation result.
+     */
+    async gasEstimate(params) {
+        this.readOnlyProviders = await createReadOnlyProviders(this.config, this.readOnlyProviders);
+        return await gasEstimator(params, this.readOnlyProviders, this.config);
+    }
+    /**
+     * Creates and returns a URL for the fiat ramp widget.
+     * @param {FiatRampParams} params - The parameters for creating the url.
+     * @returns {Promise<string>} - A promise that resolves to a string url.
+     */
+    async createFiatRampUrl(params) {
+        let tokenAmount;
+        let tokenSymbol = 'IMX';
+        let email;
+        const walletAddress = await params.web3Provider.getSigner().getAddress();
+        const isPassport = params.web3Provider.provider?.isPassport || false;
+        if (isPassport && params.passport) {
+            const userInfo = await params.passport.getUserInfo();
+            email = userInfo?.email;
         }
-        catch (err) {
-            throw new CheckoutError('An error occurred while executing the fulfillment transaction', CheckoutErrorType.EXECUTE_FULFILLMENT_TRANSACTION_ERROR, {
-                message: err.message,
-            });
+        const tokenList = await getTokenAllowList(this.config, { type: TokenFilterTypes.ONRAMP });
+        const token = tokenList.tokens?.find((t) => isMatchingAddress(t.address, params.tokenAddress));
+        if (token) {
+            tokenAmount = params.tokenAmount;
+            tokenSymbol = token.symbol;
         }
-        return {
-            status: CheckoutStatus.FULFILLMENTS_UNSETTLED,
-            smartCheckoutResult,
-            transactions,
+        return await this.fiatRampService.createWidgetUrl({
+            exchangeType: params.exchangeType,
+            isPassport,
+            walletAddress,
+            tokenAmount,
+            tokenSymbol,
+            email,
+        });
+    }
+    /**
+     * Fetches fiat ramp fee estimations.
+     * @returns {Promise<OnRampProviderFees>} - A promise that resolves to OnRampProviderFees.
+     */
+    async getExchangeFeeEstimate() {
+        return await this.fiatRampService.feeEstimate();
+    }
+    /**
+     * Fetches Swap widget availability.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean.
+     */
+    async isSwapAvailable() {
+        return this.availability.checkDexAvailability();
+    }
+}
+
+class BlockExplorerService {
+    /**
+     * getTransationLink returns the link to the transaction on blockscout
+     * @param hash transaction hash
+     * @returns link to the transaction on blockscout
+     */
+    static getTransactionLink(chainId, hash) {
+        const url = BLOCKSCOUT_CHAIN_URL_MAP?.[chainId]?.url;
+        if (!url || !hash)
+            return undefined;
+        return `${url}/tx/${hash}`;
+    }
+}
+
+var checkout = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BlockExplorerService: BlockExplorerService,
+    get BridgeEventType () { return BridgeEventType; },
+    get ChainId () { return ChainId; },
+    get ChainName () { return ChainName; },
+    get ChainSlug () { return ChainSlug; },
+    Checkout: Checkout,
+    CheckoutConfiguration: CheckoutConfiguration,
+    get CheckoutErrorType () { return CheckoutErrorType; },
+    get CheckoutStatus () { return CheckoutStatus; },
+    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; },
+    IMMUTABLE_API_BASE_URL: IMMUTABLE_API_BASE_URL,
+    get IMTBLWidgetEvents () { return IMTBLWidgetEvents; },
+    get ItemType () { return ItemType; },
+    get NetworkFilterTypes () { return NetworkFilterTypes; },
+    get OnRampEventType () { return OnRampEventType; },
+    get OrchestrationEventType () { return OrchestrationEventType; },
+    get ProviderEventType () { return ProviderEventType; },
+    get RoutingOutcomeType () { return RoutingOutcomeType; },
+    get SaleEventType () { return SaleEventType; },
+    get SalePaymentTypes () { return SalePaymentTypes; },
+    get SwapEventType () { return SwapEventType; },
+    get TokenFilterTypes () { return TokenFilterTypes; },
+    get TransactionOrGasType () { return TransactionOrGasType; },
+    get WalletEventType () { return WalletEventType; },
+    get WalletFilterTypes () { return WalletFilterTypes; },
+    get WalletProviderName () { return WalletProviderName; },
+    get WidgetTheme () { return WidgetTheme; },
+    get WidgetType () { return WidgetType; }
+});
+
+function isChainValid(chainID, config) {
+    return chainID === config.ethConfiguration.chainID;
+}
+async function validateChain(signer, config) {
+    const chainID = await signer.getChainId();
+    if (!isChainValid(chainID, config)) {
+        throw new Error('The wallet used for this operation is not connected to the correct network.');
+    }
+}
+
+async function transfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
+    const transferAmount = request.type === 'ERC721' ? '1' : request.amount;
+    const signableResult = await transfersApi.getSignableTransferV1({
+        getSignableTransferRequest: {
+            sender: ethAddress,
+            token: convertToSignableToken(request),
+            amount: transferAmount,
+            receiver: request.receiver,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, ethSigner);
+    const starkSignature = await starkSigner.signMessage(payloadHash);
+    const transferSigningParams = {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        sender_stark_key: signableResult.data.sender_stark_key,
+        sender_vault_id: signableResult.data.sender_vault_id,
+        receiver_stark_key: signableResult.data.receiver_stark_key,
+        receiver_vault_id: signableResult.data.receiver_vault_id,
+        asset_id: signableResult.data.asset_id,
+        amount: signableResult.data.amount,
+        nonce: signableResult.data.nonce,
+        expiration_timestamp: signableResult.data.expiration_timestamp,
+        stark_signature: starkSignature,
+    };
+    const response = await transfersApi.createTransferV1({
+        createTransferRequest: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        sent_signature: response?.data.sent_signature,
+        status: response?.data.status?.toString(),
+        time: response?.data.time,
+        transfer_id: response?.data.transfer_id,
+    };
+}
+async function batchTransfer({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const transfersApi = new coreSdk.TransfersApi(config.immutableXConfig.apiConfiguration);
+    const signableRequests = request.map((nftTransfer) => ({
+        amount: '1',
+        token: convertToSignableToken({
+            type: 'ERC721',
+            tokenId: nftTransfer.tokenId,
+            tokenAddress: nftTransfer.tokenAddress,
+        }),
+        receiver: nftTransfer.receiver,
+    }));
+    const signableResult = await transfersApi.getSignableTransfer({
+        getSignableTransferRequestV2: {
+            sender_ether_key: ethAddress,
+            signable_requests: signableRequests,
+        },
+    });
+    const signableMessage = signableResult.data.signable_message;
+    if (signableMessage === undefined) {
+        throw new Error('Invalid response from Signable registration offchain');
+    }
+    const ethSignature = await signRaw(signableMessage, ethSigner);
+    const requests = [];
+    for (const resp of signableResult.data.signable_responses) {
+        // TODO: remove once fixed
+        // eslint-disable-next-line no-await-in-loop
+        const starkSignature = await starkSigner.signMessage(resp.payload_hash);
+        const req = {
+            sender_vault_id: resp.sender_vault_id,
+            receiver_stark_key: resp.receiver_stark_key,
+            receiver_vault_id: resp.receiver_vault_id,
+            asset_id: resp.asset_id,
+            amount: resp.amount,
+            nonce: resp.nonce,
+            expiration_timestamp: resp.expiration_timestamp,
+            stark_signature: starkSignature,
         };
+        requests.push(req);
     }
+    // TODO: throw error on missing payload hash?
+    const transferSigningParams = {
+        sender_stark_key: signableResult.data.sender_stark_key,
+        requests,
+    };
+    const response = await transfersApi.createTransfer({
+        createTransferRequestV2: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        transfer_ids: response?.data.transfer_ids,
+    };
+}
+
+async function createOrder({ signers, request, config, }) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
+    const amountSell = request.sell.type === 'ERC721' ? '1' : request.sell.amount;
+    const amountBuy = request.buy.type === 'ERC721' ? '1' : request.buy.amount;
+    const getSignableOrderRequest = {
+        user: ethAddress,
+        amount_buy: amountBuy,
+        token_buy: convertToSignableToken(request.buy),
+        amount_sell: amountSell,
+        token_sell: convertToSignableToken(request.sell),
+        fees: request.fees,
+        expiration_timestamp: request.expiration_timestamp,
+    };
+    const getSignableOrderResponse = await ordersApi.getSignableOrder({
+        getSignableOrderRequestV3: getSignableOrderRequest,
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableOrderResponse.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const resp = getSignableOrderResponse.data;
+    const orderParams = {
+        createOrderRequest: {
+            amount_buy: resp.amount_buy,
+            amount_sell: resp.amount_sell,
+            asset_id_buy: resp.asset_id_buy,
+            asset_id_sell: resp.asset_id_sell,
+            expiration_timestamp: resp.expiration_timestamp,
+            fees: request.fees,
+            nonce: resp.nonce,
+            stark_key: resp.stark_key,
+            stark_signature: starkSignature,
+            vault_id_buy: resp.vault_id_buy,
+            vault_id_sell: resp.vault_id_sell,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    };
+    const createOrderResponse = await ordersApi.createOrderV3(orderParams);
     return {
-        status: CheckoutStatus.INSUFFICIENT_FUNDS,
-        smartCheckoutResult,
+        ...createOrderResponse.data,
     };
-};
+}
+async function cancelOrder({ signers, request, config, }) {
+    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
+    const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3({
+        getSignableCancelOrderRequest: {
+            order_id: request.order_id,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const cancelOrderResponse = await ordersApi.cancelOrderV3({
+        id: request.order_id.toString(),
+        cancelOrderRequest: {
+            order_id: request.order_id,
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        order_id: cancelOrderResponse.data.order_id,
+        status: cancelOrderResponse.data.status,
+    };
+}
 
-const cancel = async (config, provider, orderIds, overrides = {
-    waitFulfillmentSettlements: true,
-}) => {
-    let unsignedCancelOrderTransaction;
-    if (orderIds.length === 0) {
-        throw new CheckoutError('No orderIds were provided to the orderIds array. Please provide at least one orderId.', CheckoutErrorType.CANCEL_ORDER_LISTING_ERROR);
-    }
-    // Update this when bulk cancel is supported
-    const orderId = orderIds[0];
+async function registerOffchain(signers, config) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const usersApi = new coreSdk.UsersApi(config.immutableXConfig.apiConfiguration);
+    const userAddress = await signers.ethSigner.getAddress();
+    const starkPublicKey = await signers.starkSigner.getAddress();
+    const signableResult = await usersApi.getSignableRegistrationOffchain({
+        getSignableRegistrationRequest: {
+            ether_key: userAddress,
+            stark_key: starkPublicKey,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const registeredUser = await usersApi.registerUser({
+        registerUserRequest: {
+            eth_signature: ethSignature,
+            ether_key: userAddress,
+            stark_signature: starkSignature,
+            stark_key: starkPublicKey,
+        },
+    });
+    return registeredUser.data;
+}
+async function isRegisteredOffchain(ethAddress, config) {
     try {
-        const offererAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
-        const orderbook = createOrderbookInstance(config);
-        const cancelOrderResponse = await measureAsyncExecution(config, 'Time to get the cancel order from the orderbook', orderbook.cancelOrdersOnChain([orderId], offererAddress));
-        unsignedCancelOrderTransaction = await cancelOrderResponse.cancellationAction.buildTransaction();
-    }
-    catch (err) {
-        throw new CheckoutError('An error occurred while cancelling the order listing', CheckoutErrorType.CANCEL_ORDER_LISTING_ERROR, {
-            orderId,
-            error: err,
+        const usersApi = new coreSdk.UsersApi(config.immutableXConfig.apiConfiguration);
+        const getUsersResult = await usersApi.getUsers({
+            user: ethAddress,
         });
+        const { accounts } = getUsersResult.data;
+        return accounts?.length > 0;
     }
-    if (overrides.waitFulfillmentSettlements) {
-        const result = await signFulfillmentTransactions(provider, [unsignedCancelOrderTransaction]);
-        if (result.type === SignTransactionStatusType.FAILED) {
-            return {
-                status: CheckoutStatus.FAILED,
-                transactionHash: result.transactionHash,
-                reason: result.reason,
-            };
+    catch (ex) {
+        if (ex instanceof globalAxios$1.AxiosError && ex.response?.status === 404) {
+            return false;
         }
-        return {
-            status: CheckoutStatus.SUCCESS,
-        };
+        throw ex;
     }
-    let transactions;
+}
+async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const registrationContract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
     try {
-        const response = await Promise.all([unsignedCancelOrderTransaction].map((transaction) => sendTransaction(provider, transaction)));
-        transactions = response.map((result) => result.transactionResponse);
+        return await registrationContract.isRegistered(starkPublicKey);
     }
-    catch (err) {
-        throw new CheckoutError('An error occurred while executing the fulfillment transaction', CheckoutErrorType.EXECUTE_FULFILLMENT_TRANSACTION_ERROR, {
-            message: err.message,
-        });
+    catch (ex) {
+        if (ex.reason === 'USER_UNREGISTERED') {
+            return false;
+        }
+        throw ex;
     }
+}
+async function getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi) {
+    const response = await usersApi.getSignableRegistration({
+        getSignableRegistrationRequest: {
+            ether_key: etherKey,
+            stark_key: starkPublicKey,
+        },
+    });
     return {
-        status: CheckoutStatus.FULFILLMENTS_UNSETTLED,
-        transactions,
+        operator_signature: response.data.operator_signature,
+        payload_hash: response.data.payload_hash,
+        readable_transaction: response.data.readable_transaction,
+        verification_signature: response.data.verification_signature,
     };
-};
+}
 
-const getERC721Requirement = (id, contractAddress, spenderAddress) => ({
-    type: ItemType.ERC721,
-    id,
-    contractAddress,
-    spenderAddress,
-});
-const getBuyToken = (buyToken, decimals = 18) => {
-    const bnAmount = ethers.utils.parseUnits(buyToken.amount, decimals);
-    if (buyToken.type === ItemType.NATIVE) {
-        return {
-            type: ItemType.NATIVE,
-            amount: bnAmount.toString(),
-        };
-    }
-    return {
-        type: ItemType.ERC20,
-        amount: bnAmount.toString(),
-        contractAddress: buyToken.tokenAddress,
-    };
+const assertIsDefined = (value) => {
+    if (value !== undefined)
+        return value;
+    throw new Error('undefined field exception');
 };
-const sell = async (config, provider, orders) => {
-    let orderbook;
-    let listing;
-    let spenderAddress = '';
-    if (orders.length === 0) {
-        throw new CheckoutError('No orders were provided to the orders array. Please provide at least one order.', CheckoutErrorType.PREPARE_ORDER_LISTING_ERROR);
-    }
-    const { buyToken, sellToken, makerFees, orderExpiry, } = orders[0];
-    let decimals = 18;
-    if (buyToken.type === ItemType.ERC20) {
-        // get this from the allowed list
-        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);
-    try {
-        const walletAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
-        orderbook = createOrderbookInstance(config);
-        const { seaportContractAddress } = orderbook.config();
-        spenderAddress = seaportContractAddress;
-        listing = await measureAsyncExecution(config, 'Time to prepare the listing from the orderbook', orderbook.prepareListing({
-            makerAddress: walletAddress,
-            buy: buyTokenOrNative,
-            sell: {
-                type: ItemType.ERC721,
-                contractAddress: sellToken.collectionAddress,
-                tokenId: sellToken.id,
+async function prepareWithdrawalAction(params) {
+    const { signers: { ethSigner, starkSigner }, type, config, } = params;
+    await validateChain(ethSigner, params.config);
+    const withdrawalsApi = new coreSdk.WithdrawalsApi(config.apiConfiguration);
+    const withdrawalAmount = type === 'ERC721' ? '1' : params.amount;
+    const signableWithdrawalResult = await withdrawalsApi.getSignableWithdrawal({
+        getSignableWithdrawalRequest: {
+            user: await ethSigner.getAddress(),
+            token: convertToSignableToken(params),
+            amount: withdrawalAmount,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableWithdrawalResult.data;
+    const starkSignature = await starkSigner.signMessage(payloadHash);
+    const { ethAddress, ethSignature } = await signMessage$1(signableMessage, ethSigner);
+    const prepareWithdrawalResponse = await withdrawalsApi.createWithdrawal({
+        createWithdrawalRequest: {
+            stark_key: assertIsDefined(signableWithdrawalResult.data.stark_key),
+            amount: withdrawalAmount,
+            asset_id: assertIsDefined(signableWithdrawalResult.data.asset_id),
+            vault_id: assertIsDefined(signableWithdrawalResult.data.vault_id),
+            nonce: assertIsDefined(signableWithdrawalResult.data.nonce),
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return prepareWithdrawalResponse.data;
+}
+
+async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
+    const encodingApi = new coreSdk.EncodingApi(config.apiConfiguration);
+    const result = await encodingApi.encodeAsset({
+        assetType,
+        encodeAssetRequest: {
+            token: {
+                type: tokenType,
+                ...(tokenData && { data: tokenData }),
             },
-            orderExpiry,
-        }));
-    }
-    catch (err) {
-        throw new CheckoutError('An error occurred while preparing the listing', CheckoutErrorType.PREPARE_ORDER_LISTING_ERROR, {
-            error: err,
-            id: sellToken.id,
-            collectionAddress: sellToken.collectionAddress,
-        });
-    }
-    const itemRequirements = [
-        getERC721Requirement(sellToken.id, sellToken.collectionAddress, spenderAddress),
-    ];
-    const smartCheckoutResult = await measureAsyncExecution(config, 'Total time running smart checkout', smartCheckout(config, provider, itemRequirements, {
-        type: TransactionOrGasType.GAS,
-        gasToken: {
-            type: GasTokenType.NATIVE,
-            limit: ethers.BigNumber.from(constants.estimatedFulfillmentGasGwei),
         },
-    }));
-    if (smartCheckoutResult.sufficient) {
-        const unsignedTransactions = await getUnsignedERC721Transactions(listing.actions);
-        const approvalResult = await signApprovalTransactions(provider, unsignedTransactions.approvalTransactions);
-        if (approvalResult.type === SignTransactionStatusType.FAILED) {
-            return {
-                status: CheckoutStatus.FAILED,
-                transactionHash: approvalResult.transactionHash,
-                reason: approvalResult.reason,
-                smartCheckoutResult,
-            };
-        }
-        const unsignedMessage = getUnsignedMessage(listing.orderHash, listing.orderComponents, listing.actions);
-        if (!unsignedMessage) {
-            // For sell it is expected the orderbook will always return an unsigned message
-            // If for some reason it is missing then we cannot proceed with the create listing
-            throw new CheckoutError('The unsigned message is missing after preparing the listing', CheckoutErrorType.SIGN_MESSAGE_ERROR, {
-                id: sellToken.id,
-                collectionAddress: sellToken.collectionAddress,
-            });
-        }
-        const signedMessage = await signMessage(provider, unsignedMessage);
-        let orderId = '';
-        const createListingParams = {
-            orderComponents: signedMessage.orderComponents,
-            orderHash: signedMessage.orderHash,
-            orderSignature: signedMessage.signedMessage,
-            makerFees: [],
-        };
-        if (makerFees !== undefined) {
-            const orderBookFees = calculateFees(makerFees, buyTokenOrNative.amount, decimals);
-            if (orderBookFees.length !== makerFees.length) {
-                throw new CheckoutError('One of the fees is too small, must be greater than 0.000001', CheckoutErrorType.CREATE_ORDER_LISTING_ERROR);
-            }
-            createListingParams.makerFees = orderBookFees;
-        }
-        try {
-            const order = await orderbook.createListing(createListingParams);
-            orderId = order.result.id;
-        }
-        catch (err) {
-            throw new CheckoutError('An error occurred while creating the listing', CheckoutErrorType.CREATE_ORDER_LISTING_ERROR, {
-                error: err,
-                collectionId: sellToken.id,
-                collectionAddress: sellToken.collectionAddress,
-            });
-        }
-        return {
-            status: CheckoutStatus.SUCCESS,
-            orderIds: [orderId],
-            smartCheckoutResult,
-        };
-    }
-    return {
-        status: CheckoutStatus.INSUFFICIENT_FUNDS,
-        smartCheckoutResult,
-    };
-};
+    });
+    return result.data;
+}
 
-class FiatRampService {
-    config;
-    /**
-     * Constructs a new instance of the FiatRampService class.
-     * @param {CheckoutConfiguration} config - The config required for the FiatRampService.
-     */
-    constructor(config) {
-        this.config = config;
+async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
+    const etherKey = await ethSigner.getAddress();
+    const imxConfig = config.immutableXConfig;
+    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC20', imxConfig, {
+        token_address: token.tokenAddress,
+    });
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawERC20({
+            ethSigner,
+            assetType: assetType.asset_type,
+            starkPublicKey,
+            config,
+        });
     }
-    async feeEstimate() {
-        const config = (await this.config.remote.getConfig('onramp'));
-        return config[OnRampProvider.TRANSAK]?.fees;
+    return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+}
+
+async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdrawAndMint(starkPublicKey, assetType, mintingBlob);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
+    const etherKey = await ethSigner.getAddress();
+    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.regsiterAndWithdrawAndMint(etherKey, starkPublicKey, signableResult.operator_signature, assetType, mintingBlob);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+function getMintingBlob(token) {
+    const { id } = token.data;
+    const blueprint = token.data.blueprint || '';
+    return encUtils__namespace.sanitizeHex(encUtils__namespace.utf8ToHex(`{${id}}:{${blueprint}}`));
+}
+async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', imxConfig, {
+        id: token.data.id,
+        token_address: token.data.tokenAddress,
+        ...(token.data.blueprint && { blueprint: token.data.blueprint }),
+    });
+    const mintingBlob = getMintingBlob(token);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
-    async createWidgetUrl(params) {
-        return (await this.getTransakWidgetUrl(params));
+    return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
+}
+async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
+    const etherKey = await ethSigner.getAddress();
+    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.registerAndWithdrawNft(etherKey, starkPublicKey, signableResult.operator_signature, assetType, tokenId);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdrawNft(starkPublicKey, assetType, tokenId);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC721', imxConfig, {
+        token_id: token.tokenId,
+        token_address: token.tokenAddress,
+    });
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
     }
-    async getTransakWidgetUrl(params) {
-        let widgetUrl = `${TRANSAK_API_BASE_URL[this.config.environment]}?`;
-        const onRampConfig = (await this.config.remote.getConfig('onramp'));
-        const apiKey = onRampConfig[OnRampProvider.TRANSAK].publishableApiKey;
-        const transakPublishableKey = `apiKey=${apiKey}`;
-        const zkevmNetwork = 'network=immutablezkevm';
-        const defaultPaymentMethod = 'defaultPaymentMethod=credit_debit_card';
-        const disableBankTransfer = 'disablePaymentMethods=sepa_bank_transfer,gbp_bank_transfer,'
-            + 'pm_cash_app,pm_jwire,pm_paymaya,pm_bpi,pm_ubp,pm_grabpay,pm_shopeepay,pm_gcash,pm_pix,'
-            + 'pm_astropay,pm_pse,inr_bank_transfer';
-        const productsAvailed = 'productsAvailed=buy';
-        const exchangeScreenTitle = 'exchangeScreenTitle=Buy';
-        const themeColor = 'themeColor=0D0D0D';
-        widgetUrl += `${transakPublishableKey}&`
-            + `${zkevmNetwork}&`
-            + `${defaultPaymentMethod}&`
-            + `${disableBankTransfer}&`
-            + `${productsAvailed}&`
-            + `${exchangeScreenTitle}&`
-            + `${themeColor}`;
-        if (params.isPassport && params.email) {
-            const encodedEmail = encodeURIComponent(params.email);
-            widgetUrl += `&email=${encodedEmail}&isAutoFillUserData=true&disableWalletAddressForm=true`;
-        }
-        if (params.tokenAmount && params.tokenSymbol) {
-            widgetUrl += `&defaultCryptoAmount=${params.tokenAmount}&cryptoCurrencyCode=${params.tokenSymbol}`;
-        }
-        else {
-            widgetUrl += '&defaultCryptoCurrency=IMX';
-        }
-        if (params.walletAddress) {
-            widgetUrl += `&walletAddress=${params.walletAddress}`;
+    return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
+}
+async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const { tokenAddress } = token;
+    const { tokenId } = token;
+    const imxConfig = config.immutableXConfig;
+    const mintsApi = new coreSdk.MintsApi(imxConfig.apiConfiguration);
+    return await mintsApi
+        .getMintableTokenDetailsByClientTokenId({
+        tokenAddress,
+        tokenId,
+    })
+        .then((mintableToken) => completeMintableERC721Withdrawal(ethSigner, starkPublicKey, {
+        type: 'ERC721',
+        data: {
+            id: tokenId,
+            tokenAddress,
+            blueprint: mintableToken.data.blueprint,
+        },
+    }, config))
+        .catch((error) => {
+        if (error.response?.status === 404) {
+            // token is already minted on L1
+            return completeERC721Withdrawal(ethSigner, starkPublicKey, token, config);
         }
-        return widgetUrl;
+        throw error; // unable to recover from any other kind of error
+    });
+}
+
+async function executeRegisterAndWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
+    const etherKey = await ethSigner.getAddress();
+    const usersApi = new coreSdk.UsersApi(config.apiConfiguration);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const contract = coreSdk.Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
+    const contract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ETH', imxConfig);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+    }
+    return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+}
+
+async function prepareWithdrawal({ signers, withdrawal, config, }) {
+    return prepareWithdrawalAction({
+        signers,
+        config: config.immutableXConfig,
+        ...withdrawal,
+    });
+}
+// TODO: remove once fixed
+// eslint-disable-next-line consistent-return
+async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, token, config, }) {
+    // TODO: please add a reasonable default here
+    // eslint-disable-next-line default-case
+    switch (token.type) {
+        case 'ETH':
+            return completeEthWithdrawalAction({ ethSigner, starkPublicKey, config });
+        case 'ERC20':
+            return completeERC20WithdrawalAction({
+                ethSigner,
+                starkPublicKey,
+                token,
+                config,
+            });
+        case 'ERC721':
+            return completeERC721WithdrawalAction({
+                ethSigner,
+                starkPublicKey,
+                token,
+                config,
+            });
     }
 }
 
-async function getItemRequirementsFromRequirements(provider, requirements) {
-    // Get all decimal values by calling contracts for each ERC20
-    const decimalPromises = [];
-    requirements.forEach((itemRequirementParam) => {
-        if (itemRequirementParam.type === ItemType.ERC20) {
-            const { tokenAddress } = itemRequirementParam;
-            decimalPromises.push(getTokenContract(tokenAddress, ERC20ABI, provider).decimals());
-        }
+async function createTrade({ signers: { ethSigner, starkSigner }, request, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const ethAddress = await ethSigner.getAddress();
+    const tradesApi = new coreSdk.TradesApi(config.immutableXConfig.apiConfiguration);
+    const signableResult = await tradesApi.getSignableTrade({
+        getSignableTradeRequest: {
+            user: ethAddress,
+            order_id: request.order_id,
+            fees: request.fees,
+        },
     });
-    const decimals = await Promise.all(decimalPromises);
-    // Map ItemRequirementsParam objects to ItemRequirement by parsing amounts from formatted string to BigNumebrs
-    const itemRequirements = requirements.map((itemRequirementParam, index) => {
-        if (itemRequirementParam.type === ItemType.NATIVE) {
-            return {
-                ...itemRequirementParam,
-                amount: ethers.utils.parseUnits(itemRequirementParam.amount, 18),
-            };
-        }
-        if (itemRequirementParam.type === ItemType.ERC20) {
-            return {
-                ...itemRequirementParam,
-                amount: ethers.utils.parseUnits(itemRequirementParam.amount, decimals[index]),
-            };
-        }
-        return itemRequirementParam;
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, ethSigner);
+    const starkSignature = await starkSigner.signMessage(payloadHash);
+    const createTradeResponse = await tradesApi.createTradeV3({
+        createTradeRequest: {
+            amount_buy: signableResult.data.amount_buy,
+            amount_sell: signableResult.data.amount_sell,
+            asset_id_buy: signableResult.data.asset_id_buy,
+            asset_id_sell: signableResult.data.asset_id_sell,
+            expiration_timestamp: signableResult.data.expiration_timestamp,
+            fee_info: signableResult.data.fee_info,
+            fees: request.fees,
+            include_fees: true,
+            nonce: signableResult.data.nonce,
+            order_id: request.order_id,
+            stark_key: signableResult.data.stark_key,
+            vault_id_buy: signableResult.data.vault_id_buy,
+            vault_id_sell: signableResult.data.vault_id_sell,
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
     });
-    return itemRequirements;
+    return createTradeResponse.data;
 }
 
-/**
- * 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.
- * If the version is all zeros, it also returns the default checkout version.
- * Otherwise, it constructs a validated version string based on the major, minor, patch, and build numbers.
- */
-function validateAndBuildVersion(version) {
-    const defaultPackageVersion = globalPackageVersion();
-    if (version === undefined || version.major === undefined)
-        return defaultPackageVersion;
-    if (!Number.isInteger(version.major) || version.major < 0)
-        return defaultPackageVersion;
-    if (version.minor !== undefined && version.minor < 0)
-        return defaultPackageVersion;
-    if (version.patch !== undefined && version.patch < 0)
-        return defaultPackageVersion;
-    if (version.major === 0 && version.minor === undefined)
-        return defaultPackageVersion;
-    if (version.major === 0 && version.minor === 0 && version.patch === undefined)
-        return defaultPackageVersion;
-    if (version.major === 0 && version.minor === undefined && version.patch === undefined)
-        return defaultPackageVersion;
-    if (version.major === 0 && version.minor === 0 && version.patch === 0)
-        return defaultPackageVersion;
-    let validatedVersion = version.major.toString();
-    if (version.minor === undefined)
-        return validatedVersion;
-    if (Number.isInteger(version.minor)) {
-        validatedVersion += `.${version.minor.toString()}`;
+async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
+    const etherKey = await ethSigner.getAddress();
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
+async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
+    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
+}
+async function depositEth({ signers: { ethSigner }, deposit, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const user = await ethSigner.getAddress();
+    const data = {
+        decimals: 18,
+    };
+    const amount = units.parseUnits(deposit.amount, 'wei');
+    const imxConfig = config.immutableXConfig;
+    const depositsApi = new coreSdk.DepositsApi(imxConfig.apiConfiguration);
+    const encodingApi = new coreSdk.EncodingApi(imxConfig.apiConfiguration);
+    const usersApi = new coreSdk.UsersApi(imxConfig.apiConfiguration);
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
+        },
+        amount: amount.toString(),
+    };
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
+    });
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
+        encodeAssetRequest: {
+            token: {
+                type: deposit.type,
+            },
+        },
+    });
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
     }
-    if (version.patch === undefined)
-        return validatedVersion;
-    if (Number.isInteger(version.patch)) {
-        validatedVersion += `.${version.patch.toString()}`;
+    return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
+}
+
+async function executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config, usersApi) {
+    const etherKey = await ethSigner.getAddress();
+    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
+    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositERC20(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositERC20(starkPublicKey, assetType, vaultId, quantizedAmount);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
+    const user = await ethSigner.getAddress();
+    const tokensApi = new coreSdk.TokensApi(apiConfiguration);
+    const depositsApi = new coreSdk.DepositsApi(apiConfiguration);
+    const encodingApi = new coreSdk.EncodingApi(apiConfiguration);
+    const usersApi = new coreSdk.UsersApi(apiConfiguration);
+    // Get decimals for this specific ERC20
+    const token = await tokensApi.getToken({ address: deposit.tokenAddress });
+    // TODO: remove once fixed
+    // eslint-disable-next-line radix
+    const decimals = parseInt(token.data.decimals);
+    const data = {
+        decimals,
+        token_address: deposit.tokenAddress,
+    };
+    const amount = units.parseUnits(deposit.amount, 0); // 0 to always use undecimalized value
+    // Approve whether an amount of token from an account can be spent by a third-party account
+    const tokenContract = coreSdk.Contracts.IERC20.connect(deposit.tokenAddress, ethSigner);
+    const approveTransaction = await tokenContract.populateTransaction.approve(ethConfiguration.coreContractAddress, amount);
+    await ethSigner.sendTransaction(approveTransaction);
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
+        },
+        amount: amount.toString(),
+    };
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
+    });
+    // Perform encoding on asset details to get an assetType (required for stark contract request)
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
+        encodeAssetRequest: {
+            token: {
+                type: deposit.type,
+                data: {
+                    token_address: deposit.tokenAddress,
+                },
+            },
+        },
+    });
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
+    const quantizedAmount = bignumber.BigNumber.from(signableDepositResult.data.amount);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration, usersApi);
     }
-    if (version.prerelease === undefined || version.prerelease !== 'alpha')
-        return validatedVersion;
-    if (version.prerelease === 'alpha') {
-        validatedVersion += `-${version.prerelease}`;
+    return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
+}
+
+async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = coreSdk.Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const user = await ethSigner.getAddress();
+    const { immutableXConfig } = config;
+    const depositsApi = new coreSdk.DepositsApi(immutableXConfig.apiConfiguration);
+    const encodingApi = new coreSdk.EncodingApi(immutableXConfig.apiConfiguration);
+    const usersApi = new coreSdk.UsersApi(immutableXConfig.apiConfiguration);
+    const data = {
+        token_address: deposit.tokenAddress,
+        token_id: deposit.tokenId,
+    };
+    const amount = '1';
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
+        },
+        amount: amount.toString(),
+    };
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
+    });
+    // Perform encoding on asset details to get an assetType (required for stark contract request)
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
+        encodeAssetRequest: {
+            token: {
+                type: deposit.type,
+                data: {
+                    token_address: deposit.tokenAddress,
+                    token_id: deposit.tokenId,
+                },
+            },
+        },
+    });
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    // Approve whether an amount of token from an account can be spent by a third-party account
+    const tokenContract = coreSdk.Contracts.IERC721.connect(deposit.tokenAddress, ethSigner);
+    const operator = immutableXConfig.ethConfiguration.coreContractAddress;
+    const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
+    if (!isApprovedForAll) {
+        await tokenContract.setApprovalForAll(operator, true);
     }
-    if (version.build === undefined)
-        return validatedVersion;
-    if (Number.isInteger(version.build) && version.build >= 0) {
-        validatedVersion += `.${version.build.toString()}`;
+    if (!isRegistered) {
+        const signableResult = await getSignableRegistrationOnchain(user, starkPublicKey, usersApi);
+        const coreContract = coreSdk.Contracts.Core.connect(immutableXConfig.ethConfiguration.coreContractAddress, ethSigner);
+        // Note: proxy registration contract registerAndDepositNft method is not used as
+        // it currently fails erc721 transfer ownership check
+        await coreContract.registerUser(user, starkPublicKey, signableResult.operator_signature);
     }
-    return validatedVersion;
+    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, immutableXConfig);
 }
 
-function loadUnresolved(version) {
-    if (window === undefined) {
-        throw new Error('missing window object: please run Checkout client side');
-    }
-    if (document === undefined) {
-        throw new Error('missing document object: please run Checkout client side');
+// TODO: remove once fixed deposit variable shadowing
+// eslint-disable-next-line consistent-return, @typescript-eslint/no-shadow
+async function deposit({ signers, deposit, config }) {
+    // TODO: please add a reasonable default here
+    // eslint-disable-next-line default-case
+    switch (deposit.type) {
+        case 'ETH':
+            return depositEth({ signers, deposit, config });
+        case 'ERC20':
+            return depositERC20({ signers, deposit, config });
+        case 'ERC721':
+            return depositERC721({ signers, deposit, config });
     }
-    const scriptId = 'immutable-checkout-widgets-bundle';
-    const validVersion = validateAndBuildVersion(version);
-    // Prevent the script to be loaded more than once
-    // by checking the presence of the script and its version.
-    const initScript = document.getElementById(scriptId);
-    if (initScript)
-        return { loaded: true, element: initScript };
-    const tag = document.createElement('script');
-    let cdnUrl = `https://cdn.jsdelivr.net/npm/@imtbl/sdk@${validVersion}/dist/browser/checkout/widgets.js`;
-    tag.setAttribute('id', scriptId);
-    tag.setAttribute('data-version', validVersion);
-    tag.setAttribute('src', cdnUrl);
-    document.head.appendChild(tag);
-    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 {
+async function exchangeTransfer({ signers, request, config, }) {
+    await validateChain(signers.ethSigner, config.immutableXConfig);
+    const exchangeApi = new coreSdk.ExchangesApi(config.immutableXConfig.apiConfiguration);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const transferAmount = request.amount;
+    const signableResult = await exchangeApi.getExchangeSignableTransfer({
+        id: request.transactionID,
+        getSignableTransferRequest: {
+            sender: ethAddress,
+            token: convertToSignableToken(request),
+            amount: transferAmount,
+            receiver: request.receiver,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const transferSigningParams = {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        sender_stark_key: signableResult.data.sender_stark_key,
+        sender_vault_id: signableResult.data.sender_vault_id,
+        receiver_stark_key: signableResult.data.receiver_stark_key,
+        receiver_vault_id: signableResult.data.receiver_vault_id,
+        asset_id: signableResult.data.asset_id,
+        amount: signableResult.data.amount,
+        nonce: signableResult.data.nonce,
+        expiration_timestamp: signableResult.data.expiration_timestamp,
+        stark_signature: starkSignature,
+    };
+    const response = await exchangeApi.createExchangeTransfer({
+        id: request.transactionID,
+        createTransferRequest: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        sent_signature: response?.data.sent_signature,
+        status: response?.data.status?.toString(),
+        time: response?.data.time,
+        transfer_id: response?.data.transfer_id,
+    };
+}
+
+class GenericIMXProvider {
     config;
-    axiosInstance;
-    constructor(config) {
+    signers;
+    constructor(config, ethSigner, starkSigner) {
         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));
+        this.signers = { ethSigner, starkSigner };
     }
-    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));
+    async getAddress() {
+        return this.signers.ethSigner.getAddress();
     }
-    async request(config) {
-        return await this.axiosInstance.request(config);
+    async isRegisteredOffchain() {
+        const ethAddress = await this.getAddress();
+        return isRegisteredOffchain(ethAddress, this.config);
     }
-    async get(url, config) {
-        const requestConfig = {
-            ...config,
-            url,
-        };
-        return await this.request(requestConfig);
+    registerOffchain() {
+        return registerOffchain(this.signers, this.config);
     }
-    async post(url, data, config) {
-        const requestConfig = {
-            ...config,
-            data,
-            url,
-        };
-        return await this.request(requestConfig);
+    batchNftTransfer(request) {
+        return batchTransfer({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
-    async put(url, data, config) {
-        const requestConfig = {
-            ...config,
-            data,
-            url,
-        };
-        return await this.request(requestConfig);
+    cancelOrder(request) {
+        return cancelOrder({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
-    async delete(url, data, config) {
-        const requestConfig = {
-            ...config,
-            data,
-            url,
-        };
-        return await this.request(requestConfig);
+    completeWithdrawal(starkPublicKey, token) {
+        return completeWithdrawal({
+            config: this.config,
+            signers: this.signers,
+            token,
+            starkPublicKey,
+        });
     }
-}
-
-const SANDBOX_CONFIGURATION = {
-    baseConfig: {
-        environment: Environment$1.SANDBOX,
-    },
-    passport: undefined,
-};
-const WIDGETS_SCRIPT_TIMEOUT = 100;
-// Checkout SDK
-class Checkout {
-    readOnlyProviders;
-    httpClient;
-    config;
-    fiatRampService;
-    availability;
-    passport;
-    /**
-     * Constructs a new instance of the CheckoutModule class.
-     * @param {CheckoutModuleConfiguration} [config=SANDBOX_CONFIGURATION] - The configuration object for the CheckoutModule.
-     */
-    constructor(config = SANDBOX_CONFIGURATION) {
-        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);
-        this.passport = config.passport;
+    createOrder(request) {
+        return createOrder({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
-    /**
-     * Loads the widgets bundle and initiate the widgets factory.
-     * @param {WidgetsInit} init - The initialisation parameters for loading the widgets bundle and applying configuration
-     */
-    async widgets(init) {
-        const checkout = this;
-        // Preload the configurations
-        await checkout.config.remote.getConfig();
-        const factory = new Promise((resolve, reject) => {
-            function checkForWidgetsBundleLoaded() {
-                if (typeof ImmutableCheckoutWidgets !== 'undefined') {
-                    resolve(new ImmutableCheckoutWidgets.WidgetsFactory(checkout, init.config));
-                }
-                else {
-                    // If ImmutableCheckoutWidgets is not defined, wait for set amount of time.
-                    // When time has elapsed, check again if ImmutableCheckoutWidgets is defined.
-                    // Once it's defined, the promise will resolve and setTimeout won't be called again.
-                    setTimeout(checkForWidgetsBundleLoaded, WIDGETS_SCRIPT_TIMEOUT);
-                }
-            }
-            try {
-                const script = loadUnresolved(init.version);
-                if (script.loaded && typeof ImmutableCheckoutWidgets !== 'undefined') {
-                    resolve(new ImmutableCheckoutWidgets.WidgetsFactory(checkout, init.config));
-                }
-                else {
-                    checkForWidgetsBundleLoaded();
-                }
-            }
-            catch (err) {
-                reject(new CheckoutError('Failed to load widgets script', CheckoutErrorType.WIDGETS_SCRIPT_LOAD_ERROR, { error: err }));
-            }
+    createTrade(request) {
+        return createTrade({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        return factory;
     }
-    /**
-     * Creates a provider using the given parameters.
-     * @param {CreateProviderParams} params - The parameters for creating the provider.
-     * @returns {Promise<CreateProviderResult>} A promise that resolves to the created provider.
-     */
-    async createProvider(params) {
-        return await createProvider(params.walletProviderName, this.passport);
+    deposit(tokenAmount) {
+        return deposit({
+            signers: this.signers,
+            deposit: tokenAmount,
+            config: this.config,
+        });
     }
-    /**
-     * Checks if a wallet is connected to the specified provider.
-     * @param {CheckConnectionParams} params - The parameters for checking the wallet connection.
-     * @returns {Promise<CheckConnectionResult>} - A promise that resolves to the result of the check.
-     */
-    async checkIsWalletConnected(params) {
-        const web3Provider = await validateProvider(this.config, params.provider, { allowUnsupportedProvider: true });
-        return checkIsWalletConnected(web3Provider);
+    exchangeTransfer(request) {
+        return exchangeTransfer({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
-    /**
-     * Connects to a blockchain network using the specified provider.
-     * @param {ConnectParams} params - The parameters for connecting to the network.
-     * @returns {Promise<ConnectResult>} A promise that resolves to an object containing the provider and network information.
-     * @throws {Error} If the provider is not valid or if there is an error connecting to the network.
-     */
-    async connect(params) {
-        const web3Provider = await validateProvider(this.config, params.provider, { allowUnsupportedProvider: true });
-        await connectSite(web3Provider);
-        return { provider: web3Provider };
+    async isRegisteredOnchain() {
+        const starkPublicKey = await this.signers.starkSigner.getAddress();
+        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
     }
-    /**
-     * Switches the network for the current wallet provider.
-     * @param {SwitchNetworkParams} params - The parameters for switching the network.
-     * @returns {Promise<SwitchNetworkResult>} - A promise that resolves to the result of switching the network.
-     */
-    async switchNetwork(params) {
-        const web3Provider = await validateProvider(this.config, params.provider, {
-            allowUnsupportedProvider: true,
-            allowMistmatchedChainId: true,
+    prepareWithdrawal(request) {
+        return prepareWithdrawal({
+            signers: this.signers,
+            withdrawal: request,
+            config: this.config,
         });
-        const switchNetworkRes = await switchWalletNetwork(this.config, web3Provider, params.chainId);
-        return switchNetworkRes;
     }
-    /**
-     * Retrieves the token information given the token address. This function makes RPC calls to
-     * ERC20 contracts to fetch the main contract information (e.g. symbol).
-     * @param {GetTokenInfoParams} params - The parameters for retrieving the token information.
-     * @returns {Promise<TokenInfo>} - A promise that resolves to the token info request.
-     */
-    async getTokenInfo(params) {
-        return await getERC20TokenInfo(params.provider, params.tokenAddress);
+    transfer(request) {
+        return transfer({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
-    /**
-     * Retrieves the balance of a wallet address.
-     * @param {GetBalanceParams} params - The parameters for retrieving the balance.
-     * @returns {Promise<GetBalanceResult>} - A promise that resolves to the balance result.
-     */
-    async getBalance(params) {
-        const web3Provider = await validateProvider(this.config, params.provider);
-        if (!params.tokenAddress || params.tokenAddress === '') {
-            return await getBalance(this.config, web3Provider, params.walletAddress);
-        }
-        return await getERC20Balance(web3Provider, params.walletAddress, params.tokenAddress);
+}
+
+const WALLET_ACTION = {
+    // TODO: remove once fixed - consider using an enum
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    SWITCH_CHAIN: 'wallet_switchEthereumChain',
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    CONNECT: 'eth_requestAccounts',
+};
+function isRequestableProvider(provider) {
+    return !!provider?.request;
+}
+async function connectProvider(provider, chainID) {
+    await provider.request({ method: WALLET_ACTION.CONNECT });
+    if (chainID) {
+        await provider.request({
+            method: WALLET_ACTION.SWITCH_CHAIN,
+            params: [{ chainId: `0x${chainID.toString(16)}` }],
+        });
     }
-    /**
-     * Retrieves the balances of all tokens for a given wallet address on a specific chain.
-     * @param {GetAllBalancesParams} params - The parameters for retrieving the balances.
-     * @returns {Promise<GetAllBalancesResult>} - A promise that resolves to the result of retrieving the balances.
-     */
-    async getAllBalances(params) {
-        return getAllBalances(this.config, params.provider, params.walletAddress, params.chainId);
+}
+
+const ERRORS = {
+    // TODO: remove once fixed - consider using something in line with the naming convention
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
+};
+async function connect$1({ chainID, }) {
+    const provider = (await detectEthereumProvider());
+    if (!isRequestableProvider(provider)) {
+        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
     }
-    /**
-     * Retrieves the supported networks based on the provided parameters.
-     * @param {GetNetworkAllowListParams} params - The parameters for retrieving the network allow list.
-     * @returns {Promise<GetNetworkAllowListResult>} - A promise that resolves to the network allow list result.
-     */
-    async getNetworkAllowList(params) {
-        return await getNetworkAllowList(this.config, params);
+    await connectProvider(provider, chainID);
+    // NOTE: if we want to listen to Metamask events in the future, we can add a
+    // listener here.
+    return new ethers.ethers.providers.Web3Provider(provider);
+}
+
+const COMMUNICATION_TYPE = 'message';
+var RequestEventType;
+(function (RequestEventType) {
+    RequestEventType["GET_CONNECTION_REQUEST"] = "GET_CONNECTION_REQUEST";
+    RequestEventType["CONNECT_WALLET_REQUEST"] = "CONNECT_WALLET_REQUEST";
+    RequestEventType["SIGN_MESSAGE_REQUEST"] = "SIGN_MESSAGE_REQUEST";
+    RequestEventType["DISCONNECT_WALLET_REQUEST"] = "DISCONNECT_WALLET_REQUEST";
+})(RequestEventType || (RequestEventType = {}));
+var ResponseEventType;
+(function (ResponseEventType) {
+    ResponseEventType["CONNECT_WALLET_RESPONSE"] = "CONNECT_WALLET_RESPONSE";
+    ResponseEventType["SIGN_MESSAGE_RESPONSE"] = "SIGN_MESSAGE_RESPONSE";
+    ResponseEventType["GET_CONNECTION_RESPONSE"] = "GET_CONNECTION_RESPONSE";
+    ResponseEventType["DISCONNECT_WALLET_RESPONSE"] = "DISCONNECT_WALLET_RESPONSE";
+})(ResponseEventType || (ResponseEventType = {}));
+
+function postRequestMessage(iframe, payload) {
+    if (iframe && iframe.contentWindow) {
+        iframe.contentWindow.postMessage(payload, new URL(iframe.src).origin);
     }
-    /**
-     * Retrieves the supported tokens based on the provided parameters.
-     * @param {GetTokenAllowListParams} params - The parameters for retrieving the token allow list.
-     * @returns {Promise<GetTokenAllowListResult>} - A promise that resolves to the token allow list result.
-     */
-    async getTokenAllowList(params) {
-        return await getTokenAllowList(this.config, params);
+}
+
+function messageResponseListener(iframe, event, eventType, callback) {
+    if (iframe && event.source !== iframe.contentWindow) {
+        return;
     }
-    /**
-     * Retrieves the default supported wallets based on the provided parameters.
-     * @param {GetWalletAllowListParams} params - The parameters for retrieving the wallet allow list.
-     * @returns {Promise<GetWalletAllowListResult>} - A promise that resolves to the wallet allow list result.
-     */
-    async getWalletAllowList(params) {
-        return await getWalletAllowList(params);
+    const l2WalletMessage = event.data;
+    if (l2WalletMessage.type !== eventType) {
+        return;
     }
-    /**
-     * Sends a transaction using the specified provider and transaction parameters.
-     * @param {SendTransactionParams} params - The parameters for sending the transaction.
-     * @returns {Promise<SendTransactionResult>} A promise that resolves to the result of the transaction.
-     */
-    async sendTransaction(params) {
-        const web3Provider = await validateProvider(this.config, params.provider);
-        return await sendTransaction(web3Provider, params.transaction);
+    callback(l2WalletMessage.details);
+}
+
+class ImxSigner {
+    publicAddress;
+    iframe;
+    constructor(publicAddress, iframe) {
+        this.publicAddress = publicAddress;
+        this.iframe = iframe;
     }
-    /**
-     * Retrieves network information using the specified provider.
-     * @param {GetNetworkParams} params - The parameters for retrieving network information.
-     * @returns {Promise<NetworkInfo>} A promise that resolves to the network information.
-     */
-    async getNetworkInfo(params) {
-        const web3Provider = await validateProvider(this.config, params.provider, {
-            allowUnsupportedProvider: true,
-            allowMistmatchedChainId: true,
-        });
-        return await getNetworkInfo(this.config, web3Provider);
+    getAddress() {
+        return this.publicAddress;
     }
-    /**
-     * Determines the requirements for performing a buy.
-     * @param {BuyParams} params - The parameters for the buy.
-    */
-    async buy(params) {
-        if (params.orders.length > 1) {
-            // eslint-disable-next-line no-console
-            console.warn('This endpoint currently only processes the first order in the array.');
-        }
-        const web3Provider = await validateProvider(this.config, params.provider);
-        return await buy(this.config, web3Provider, params.orders, params.overrides);
+    signMessage(rawMessage) {
+        return new Promise((resolve, reject) => {
+            const listener = (event) => {
+                messageResponseListener(this.iframe, event, ResponseEventType.SIGN_MESSAGE_RESPONSE, (messageDetails) => {
+                    window.removeEventListener(COMMUNICATION_TYPE, listener);
+                    if (!messageDetails.success) {
+                        reject(new Error(messageDetails.error?.message));
+                    }
+                    resolve(messageDetails.data.signedMessage);
+                });
+            };
+            window.addEventListener(COMMUNICATION_TYPE, listener);
+            postRequestMessage(this.iframe, {
+                type: RequestEventType.SIGN_MESSAGE_REQUEST,
+                details: { starkPublicKey: this.publicAddress, message: rawMessage },
+            });
+        });
     }
-    /**
-     * Determines the requirements for performing a sell.
-     * @param {SellParams} params - The parameters for the sell.
-     * Only currently actions the first order in the array until we support batch processing.
-     * Only currently actions the first fee in the fees array of each order until we support multiple fees.
-    */
-    async sell(params) {
-        if (params.orders.length > 1) {
-            // eslint-disable-next-line no-console
-            console.warn('This endpoint currently only processes the first order in the array.');
-        }
-        const web3Provider = await validateProvider(this.config, params.provider);
-        return await sell(this.config, web3Provider, params.orders);
+    getIFrame() {
+        return this.iframe;
     }
-    /**
-     * Cancels a sell.
-     * @param {CancelParams} params - The parameters for the cancel.
-     */
-    async cancel(params) {
-        // eslint-disable-next-line no-console
-        console.warn('This endpoint currently only processes the first order in the array.');
-        const web3Provider = await validateProvider(this.config, params.provider);
-        return await cancel(this.config, web3Provider, params.orderIds, params.overrides);
+}
+
+const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
+const IMX_WALLET_IFRAME_HOSTS = {
+    [Environment$1.SANDBOX]: 'https://wallets.sandbox.immutable.com',
+    [Environment$1.PRODUCTION]: 'https://wallets.immutable.com',
+};
+const IMX_WALLET_IFRAME_STYLE = 'display: none;';
+function getIFrame() {
+    return document.querySelector(`iframe#${IMX_WALLET_IFRAME_ID}`);
+}
+async function setupIFrame(env) {
+    return new Promise((resolve) => {
+        const iframe = document.createElement('iframe');
+        iframe.setAttribute('id', IMX_WALLET_IFRAME_ID);
+        iframe.setAttribute('src', IMX_WALLET_IFRAME_HOSTS[env]);
+        iframe.setAttribute('style', IMX_WALLET_IFRAME_STYLE);
+        document.body.appendChild(iframe);
+        iframe.onload = () => resolve(iframe);
+    });
+}
+async function getOrSetupIFrame(env) {
+    const iframe = getIFrame();
+    if (iframe)
+        return iframe;
+    return await setupIFrame(env);
+}
+
+const DEFAULT_CONNECTION_MESSAGE = 'Only sign this request if you’ve initiated an action with Immutable X.';
+const CONNECTION_FAILED_ERROR = 'The L2 IMX Wallet connection has failed';
+async function connect(l1Provider, env) {
+    const l1Signer = l1Provider.getSigner();
+    const address = await l1Signer.getAddress();
+    const signature = await l1Signer.signMessage(DEFAULT_CONNECTION_MESSAGE);
+    const iframe = await getOrSetupIFrame(env);
+    return new Promise((resolve, reject) => {
+        const listener = (event) => {
+            messageResponseListener(iframe, event, ResponseEventType.CONNECT_WALLET_RESPONSE, (messageDetails) => {
+                window.removeEventListener(COMMUNICATION_TYPE, listener);
+                if (!messageDetails.success) {
+                    reject(new Error(CONNECTION_FAILED_ERROR));
+                }
+                resolve(new ImxSigner(messageDetails.data.starkPublicKey, iframe));
+            });
+        };
+        window.addEventListener(COMMUNICATION_TYPE, listener);
+        postRequestMessage(iframe, {
+            type: RequestEventType.CONNECT_WALLET_REQUEST,
+            details: { ethAddress: address, signature },
+        });
+    });
+}
+async function disconnect(imxSigner) {
+    const iframe = imxSigner.getIFrame();
+    return new Promise((resolve, reject) => {
+        const listener = (event) => {
+            messageResponseListener(iframe, event, ResponseEventType.DISCONNECT_WALLET_RESPONSE, (messageDetails) => {
+                window.removeEventListener(COMMUNICATION_TYPE, listener);
+                if (!messageDetails.success && messageDetails.error) {
+                    reject(messageDetails.error);
+                }
+                iframe.remove();
+                resolve();
+            });
+        };
+        window.addEventListener(COMMUNICATION_TYPE, listener);
+        postRequestMessage(iframe, {
+            type: RequestEventType.DISCONNECT_WALLET_REQUEST,
+            details: { starkPublicKey: imxSigner.getAddress() },
+        });
+    });
+}
+
+var ProviderErrorType;
+(function (ProviderErrorType) {
+    ProviderErrorType["PROVIDER_CONNECTION_ERROR"] = "PROVIDER_CONNECTION_ERROR";
+    ProviderErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
+})(ProviderErrorType || (ProviderErrorType = {}));
+class ProviderError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
     }
-    /**
-     * Determines the transaction requirements to complete a purchase.
-     * @params {SmartCheckoutParams} params - The parameters for smart checkout.
-     */
-    async smartCheckout(params) {
-        const web3Provider = await validateProvider(this.config, params.provider);
-        let itemRequirements = [];
-        try {
-            itemRequirements = await getItemRequirementsFromRequirements(web3Provider, params.itemRequirements);
-        }
-        catch (err) {
-            throw new CheckoutError('Failed to map item requirements', CheckoutErrorType.ITEM_REQUIREMENTS_ERROR, { error: err });
-        }
-        return await smartCheckout(this.config, web3Provider, itemRequirements, params.transactionOrGasAmount);
+}
+const withProviderError = async (fn, customError) => {
+    try {
+        return await fn();
     }
-    /**
-     * Checks if the given object is a Web3 provider.
-     * @param {Web3Provider} web3Provider - The object to check.
-     * @returns {boolean} - True if the object is a Web3 provider, false otherwise.
-     */
-    static isWeb3Provider(web3Provider) {
-        return isWeb3Provider(web3Provider);
+    catch (error) {
+        const errorMessage = customError.message || `${error.message}` || 'UnknownError';
+        throw new ProviderError(errorMessage, customError.type);
     }
-    /**
-     * Estimates the gas required for a swap or bridge transaction.
-     * @param {GasEstimateParams} params - The parameters for the gas estimation.
-     * @returns {Promise<GasEstimateSwapResult | GasEstimateBridgeToL2Result>} - A promise that resolves to the gas estimation result.
-     */
-    async gasEstimate(params) {
-        this.readOnlyProviders = await createReadOnlyProviders(this.config, this.readOnlyProviders);
-        return await gasEstimator(params, this.readOnlyProviders, this.config);
+};
+
+class MetaMaskIMXProvider extends GenericIMXProvider {
+    static imxSigner;
+    static async connect(config) {
+        return await withProviderError(async () => {
+            const metaMaskProvider = await connect$1({
+                chainID: config.immutableXConfig.ethConfiguration.chainID,
+            });
+            this.imxSigner = await connect(metaMaskProvider, config.baseConfig.environment);
+            return new MetaMaskIMXProvider(config, metaMaskProvider.getSigner(), this.imxSigner);
+        }, { type: ProviderErrorType.WALLET_CONNECTION_ERROR });
     }
-    /**
-     * Creates and returns a URL for the fiat ramp widget.
-     * @param {FiatRampParams} params - The parameters for creating the url.
-     * @returns {Promise<string>} - A promise that resolves to a string url.
-     */
-    async createFiatRampUrl(params) {
-        let tokenAmount;
-        let tokenSymbol = 'IMX';
-        let email;
-        const walletAddress = await params.web3Provider.getSigner().getAddress();
-        const isPassport = params.web3Provider.provider?.isPassport || false;
-        if (isPassport && params.passport) {
-            const userInfo = await params.passport.getUserInfo();
-            email = userInfo?.email;
-        }
-        const tokenList = await getTokenAllowList(this.config, { type: TokenFilterTypes.ONRAMP });
-        const token = tokenList.tokens?.find((t) => isMatchingAddress(t.address, params.tokenAddress));
-        if (token) {
-            tokenAmount = params.tokenAmount;
-            tokenSymbol = token.symbol;
+    static async disconnect() {
+        if (!this.imxSigner) {
+            throw new ProviderError('Attempted to disconnect from the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
         }
-        return await this.fiatRampService.createWidgetUrl({
-            exchangeType: params.exchangeType,
-            isPassport,
-            walletAddress,
-            tokenAmount,
-            tokenSymbol,
-            email,
-        });
-    }
-    /**
-     * Fetches fiat ramp fee estimations.
-     * @returns {Promise<OnRampProviderFees>} - A promise that resolves to OnRampProviderFees.
-     */
-    async getExchangeFeeEstimate() {
-        return await this.fiatRampService.feeEstimate();
+        return withProviderError(async () => {
+            await disconnect(this.imxSigner);
+        }, { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
     }
-    /**
-     * Fetches Swap widget availability.
-     * @returns {Promise<boolean>} - A promise that resolves to a boolean.
-     */
-    async isSwapAvailable() {
-        return this.availability.checkDexAvailability();
+    static async signMessage(message) {
+        if (!this.imxSigner) {
+            throw new ProviderError('Attempted to sign a message with the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
+        }
+        return withProviderError(async () => await this.imxSigner.signMessage(message), { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
     }
 }
 
-class BlockExplorerService {
-    /**
-     * getTransationLink returns the link to the transaction on blockscout
-     * @param hash transaction hash
-     * @returns link to the transaction on blockscout
-     */
-    static getTransactionLink(chainId, hash) {
-        const url = BLOCKSCOUT_CHAIN_URL_MAP?.[chainId]?.url;
-        if (!url || !hash)
-            return undefined;
-        return `${url}/tx/${hash}`;
+class ProviderConfiguration {
+    immutableXConfig;
+    baseConfig;
+    constructor({ baseConfig, overrides }) {
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            this.immutableXConfig = overrides.immutableXConfig;
+        }
+        else {
+            // TODO: remove once a sensible default is chosen
+            // eslint-disable-next-line default-case
+            switch (baseConfig.environment) {
+                case Environment$1.SANDBOX: {
+                    this.immutableXConfig = coreSdk.Config.SANDBOX;
+                    break;
+                }
+                case Environment$1.PRODUCTION: {
+                    this.immutableXConfig = coreSdk.Config.PRODUCTION;
+                    break;
+                }
+            }
+        }
     }
 }
 
-var checkout = /*#__PURE__*/Object.freeze({
+var x = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    BlockExplorerService: BlockExplorerService,
-    get BridgeEventType () { return BridgeEventType; },
-    get ChainId () { return ChainId; },
-    get ChainName () { return ChainName; },
-    get ChainSlug () { return ChainSlug; },
-    Checkout: Checkout,
-    CheckoutConfiguration: CheckoutConfiguration,
-    get CheckoutErrorType () { return CheckoutErrorType; },
-    get CheckoutStatus () { return CheckoutStatus; },
-    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; },
-    IMMUTABLE_API_BASE_URL: IMMUTABLE_API_BASE_URL,
-    get IMTBLWidgetEvents () { return IMTBLWidgetEvents; },
-    get ItemType () { return ItemType; },
-    get NetworkFilterTypes () { return NetworkFilterTypes; },
-    get OnRampEventType () { return OnRampEventType; },
-    get OrchestrationEventType () { return OrchestrationEventType; },
-    get ProviderEventType () { return ProviderEventType; },
-    get RoutingOutcomeType () { return RoutingOutcomeType; },
-    get SaleEventType () { return SaleEventType; },
-    get SalePaymentTypes () { return SalePaymentTypes; },
-    get SwapEventType () { return SwapEventType; },
-    get TokenFilterTypes () { return TokenFilterTypes; },
-    get TransactionOrGasType () { return TransactionOrGasType; },
-    get WalletEventType () { return WalletEventType; },
-    get WalletFilterTypes () { return WalletFilterTypes; },
-    get WalletProviderName () { return WalletProviderName; },
-    get WidgetTheme () { return WidgetTheme; },
-    get WidgetType () { return WidgetType; }
+    GenericIMXProvider: GenericIMXProvider,
+    IMXClient: IMXClient,
+    IMXError: coreSdk.IMXError,
+    MetaMaskIMXProvider: MetaMaskIMXProvider,
+    ProviderConfiguration: ProviderConfiguration,
+    imxClientCreateStarkSigner: coreSdk.createStarkSigner,
+    imxClientGenerateLegacyStarkPrivateKey: coreSdk.generateLegacyStarkPrivateKey
 });
 
 exports.blockchainData = blockchain_data;
 exports.checkout = checkout;
 exports.config = config;
-exports.immutablexClient = immutablex_client;
 exports.orderbook = orderbook;
 exports.passport = passport;
-exports.provider = provider;
+exports.x = x;