@imtbl/sdk 0.1.2 → 0.1.4-alpha

package/dist/index.cjs

@@ -7,6 +7,10 @@ var magicSdk = require('magic-sdk');
 var oidc = require('@magic-ext/oidc');
 var BN = require('bn.js');
 var encUtils = require('enc-utils');
+var units = require('@ethersproject/units');
+var bignumber = require('@ethersproject/bignumber');
+var detectEthereumProvider = require('@metamask/detect-provider');
+var providers = require('@ethersproject/providers');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -569,6 +573,15 @@ async function signRaw(payload, signer) {
     const signature = deserializeSignature(await signer.signMessage(payload));
     return serializeEthSignature(signature);
 }
+async function signMessage(message, signer) {
+    const ethAddress = await signer.getAddress();
+    const ethSignature = await signRaw(message, signer);
+    return {
+        message,
+        ethAddress,
+        ethSignature,
+    };
+}
 
 /**
  * Helper method to convert token type to a SignableToken type
@@ -882,7 +895,7 @@ class ConfirmationScreen {
 }
 
 const ERC721$1 = 'ERC721';
-const transfer = ({ request, transfersApi, starkSigner, user, passportConfig, }) => {
+const transfer$1 = ({ request, transfersApi, starkSigner, user, passportConfig, }) => {
     return withPassportError(async () => {
         const transferAmount = request.type === ERC721$1 ? '1' : request.amount;
         const getSignableTransferRequest = {
@@ -992,7 +1005,7 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, pass
 }
 
 const ERC721 = 'ERC721';
-async function createOrder({ starkSigner, user, request, ordersApi, passportConfig, }) {
+async function createOrder$1({ starkSigner, user, request, ordersApi, passportConfig, }) {
     return withPassportError(async () => {
         const ethAddress = user.etherKey;
         const amountSell = request.sell.type === ERC721 ? '1' : request.sell.amount;
@@ -1047,7 +1060,7 @@ async function createOrder({ starkSigner, user, request, ordersApi, passportConf
         };
     }, PassportErrorType.CREATE_ORDER_ERROR);
 }
-async function cancelOrder({ user, starkSigner, request, ordersApi, passportConfig, }) {
+async function cancelOrder$1({ user, starkSigner, request, ordersApi, passportConfig, }) {
     return withPassportError(async () => {
         const getSignableCancelOrderRequest = {
             order_id: request.order_id,
@@ -1082,7 +1095,7 @@ async function cancelOrder({ user, starkSigner, request, ordersApi, passportConf
     }, PassportErrorType.CANCEL_ORDER_ERROR);
 }
 
-async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
+async function exchangeTransfer$1({ user, starkSigner, request, exchangesApi, }) {
     return withPassportError(async () => {
         const ethAddress = user.etherKey;
         const transferAmount = request.amount;
@@ -1125,7 +1138,7 @@ async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
     }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
 }
 
-async function createTrade({ request, tradesApi, user, starkSigner, passportConfig, }) {
+async function createTrade$1({ request, tradesApi, user, starkSigner, passportConfig, }) {
     return withPassportError(async () => {
         const ethAddress = user.etherKey;
         const getSignableTradeRequest = {
@@ -1177,29 +1190,20 @@ async function createTrade({ request, tradesApi, user, starkSigner, passportConf
 class PassportImxProvider {
     user;
     starkSigner;
-    transfersApi;
-    ordersApi;
     passportConfig;
-    exchangesApi;
-    tradesApi;
-    constructor({ user, starkSigner, passportConfig }) {
+    immutableXClient;
+    constructor({ user, starkSigner, passportConfig, immutableXClient, }) {
         this.user = user;
         this.starkSigner = starkSigner;
         this.passportConfig = passportConfig;
-        const apiConfig = new coreSdk.Configuration({
-            basePath: passportConfig.imxApiBasePath,
-        });
-        this.transfersApi = new coreSdk.TransfersApi(apiConfig);
-        this.ordersApi = new coreSdk.OrdersApi(apiConfig);
-        this.exchangesApi = new coreSdk.ExchangesApi(apiConfig);
-        this.tradesApi = new coreSdk.TradesApi(apiConfig);
+        this.immutableXClient = immutableXClient;
     }
     async transfer(request) {
-        return transfer({
+        return transfer$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
+            transfersApi: this.immutableXClient.transfersApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -1210,29 +1214,29 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     createOrder(request) {
-        return createOrder({
+        return createOrder$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
+            ordersApi: this.immutableXClient.ordersApi,
             passportConfig: this.passportConfig,
         });
     }
     cancelOrder(request) {
-        return cancelOrder({
+        return cancelOrder$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
+            ordersApi: this.immutableXClient.ordersApi,
             passportConfig: this.passportConfig,
         });
     }
     createTrade(request) {
-        return createTrade({
+        return createTrade$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            tradesApi: this.tradesApi,
+            tradesApi: this.immutableXClient.tradesApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -1241,16 +1245,16 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
+            transfersApi: this.immutableXClient.transfersApi,
             passportConfig: this.passportConfig,
         });
     }
     exchangeTransfer(request) {
-        return exchangeTransfer({
+        return exchangeTransfer$1({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            exchangesApi: this.exchangesApi,
+            exchangesApi: this.immutableXClient.exchangeApi,
         });
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1297,7 +1301,6 @@ class PassportConfiguration {
     passportDomain;
     magicPublishableApiKey;
     magicProviderId;
-    imxApiBasePath;
     oidcConfiguration;
     baseConfig;
     constructor({ baseConfig, overrides, ...oidcConfiguration }) {
@@ -1315,14 +1318,12 @@ class PassportConfiguration {
                 'magicPublishableApiKey',
                 'magicProviderId',
                 'passportDomain',
-                'imxApiBasePath',
             ], 'overrides');
             this.network = overrides.network;
             this.authenticationDomain = overrides.authenticationDomain;
             this.passportDomain = overrides.passportDomain;
             this.magicPublishableApiKey = overrides.magicPublishableApiKey;
             this.magicProviderId = overrides.magicProviderId;
-            this.imxApiBasePath = overrides.imxApiBasePath;
         }
         else {
             switch (baseConfig.environment) {
@@ -1332,7 +1333,6 @@ class PassportConfiguration {
                     this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
                     this.passportDomain = 'https://passport.sandbox.immutable.com';
-                    this.imxApiBasePath = 'https://api.sandbox.x.immutable.com';
                     break;
                 }
                 case exports.Environment.PRODUCTION: {
@@ -1341,7 +1341,6 @@ class PassportConfiguration {
                     this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
                     this.passportDomain = 'https://passport.immutable.com';
-                    this.imxApiBasePath = 'https://api.x.immutable.com';
                     break;
                 }
             }
@@ -1386,11 +1385,16 @@ class Passport {
     authManager;
     magicAdapter;
     config;
+    immutableXClient;
     constructor(passportModuleConfiguration) {
-        const passportConfiguration = new PassportConfiguration(passportModuleConfiguration);
-        this.config = passportConfiguration;
+        this.config = new PassportConfiguration(passportModuleConfiguration);
         this.authManager = new AuthManager(this.config);
         this.magicAdapter = new MagicAdapter(this.config);
+        this.immutableXClient =
+            passportModuleConfiguration.overrides?.immutableXClient ||
+                new ImmutableXClient({
+                    baseConfig: passportModuleConfiguration.baseConfig,
+                });
     }
     async getImxProvider(user) {
         if (!user || !user.idToken) {
@@ -1405,6 +1409,7 @@ class Passport {
                 user: updatedUser,
                 starkSigner,
                 passportConfig: this.config,
+                immutableXClient: this.immutableXClient,
             });
         }
         const userWithEtherKey = user;
@@ -1412,6 +1417,7 @@ class Passport {
             user: userWithEtherKey,
             starkSigner,
             passportConfig: this.config,
+            immutableXClient: this.immutableXClient,
         });
     }
     async connectImxSilent() {
@@ -1444,14 +1450,10 @@ class Passport {
         return user?.accessToken;
     }
     async registerUser(userAdminKeySigner, starkSigner, jwt) {
-        const configuration = new coreSdk.Configuration({
-            basePath: this.config.imxApiBasePath,
-        });
-        const usersApi = new coreSdk.UsersApi(configuration);
         await registerPassport({
             ethSigner: userAdminKeySigner,
             starkSigner,
-            usersApi,
+            usersApi: this.immutableXClient.usersApi,
         }, jwt);
         const updatedUser = await this.authManager.requestRefreshTokenAfterRegistration();
         if (!updatedUser) {
@@ -1461,6 +1463,1754 @@ class Passport {
     }
 }
 
+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) => {
+        return {
+            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) {
+        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,
+            include_fees: true,
+            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.createOrder(orderParams);
+    return {
+        ...createOrderResponse.data,
+    };
+}
+async function cancelOrder({ signers, request, config, }) {
+    const ordersApi = new coreSdk.OrdersApi(config.immutableXConfig.apiConfiguration);
+    const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
+        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.cancelOrder({
+        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,
+    };
+}
+
+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 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,
+    };
+}
+
+const assertIsDefined = (value) => {
+    if (value !== undefined)
+        return value;
+    throw new Error('undefined field exception');
+};
+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(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;
+}
+
+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,
+        });
+    }
+    else {
+        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.id;
+    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);
+    }
+    else {
+        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);
+    }
+    else {
+        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.tokenAddress;
+    const tokenId = token.tokenId;
+    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: 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
+    });
+}
+
+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);
+    }
+    else {
+        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
+    }
+}
+
+async function prepareWithdrawal({ signers, withdrawal, config, }) {
+    return prepareWithdrawalAction({
+        signers,
+        config: config.immutableXConfig,
+        ...withdrawal,
+    });
+}
+async function completeWithdrawal({ signers: { ethSigner }, starkPublicKey, token, config, }) {
+    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.createTrade({
+        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 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);
+    }
+    else {
+        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
+    }
+}
+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 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 });
+    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);
+    }
+    else {
+        return executeDepositERC20(ethSigner, quantizedAmount, assetType, starkPublicKey, vaultId, ethConfiguration);
+    }
+}
+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 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 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);
+}
+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 deposit({ signers, deposit, config }) {
+    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 await this.signers.ethSigner.getAddress();
+    }
+    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 = {
+    SWITCH_CHAIN: 'wallet_switchEthereumChain',
+    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 = {
+    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 = {
+    [exports.Environment.SANDBOX]: 'https://wallets.sandbox.immutable.com',
+    [exports.Environment.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;
+    constructor(config, ethSigner, starkSigner) {
+        super(config, ethSigner, starkSigner);
+    }
+    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 () => {
+            return 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 {
+            switch (baseConfig.environment) {
+                case exports.Environment.SANDBOX: {
+                    this.immutableXConfig = coreSdk.Config.SANDBOX;
+                    break;
+                }
+                case exports.Environment.PRODUCTION: {
+                    this.immutableXConfig = coreSdk.Config.PRODUCTION;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+
+const $762782b6c862d954$export$db5daa1b5156ccfe = [
+    {
+        constant: true,
+        inputs: [],
+        name: "name",
+        outputs: [
+            {
+                name: "",
+                type: "string"
+            }
+        ],
+        payable: false,
+        type: "function"
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: "decimals",
+        outputs: [
+            {
+                name: "",
+                type: "uint8"
+            }
+        ],
+        payable: false,
+        type: "function"
+    },
+    {
+        constant: true,
+        inputs: [
+            {
+                name: "_owner",
+                type: "address"
+            }
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                name: "balance",
+                type: "uint256"
+            }
+        ],
+        payable: false,
+        type: "function"
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: "symbol",
+        outputs: [
+            {
+                name: "",
+                type: "string"
+            }
+        ],
+        payable: false,
+        type: "function"
+    }
+];
+
+
+exports.ConnectionProviders = void 0;
+(function(ConnectionProviders) {
+    ConnectionProviders["METAMASK"] = "metamask";
+})(exports.ConnectionProviders || (exports.ConnectionProviders = {}));
+
+
+exports.ChainId = void 0;
+(function(ChainId) {
+    ChainId[ChainId["ETHEREUM"] = 1] = "ETHEREUM";
+    ChainId[ChainId["GOERLI"] = 5] = "GOERLI";
+    ChainId[ChainId["POLYGON"] = 137] = "POLYGON";
+})(exports.ChainId || (exports.ChainId = {}));
+const $a47e48dd2c04791b$export$f61f4aaec62f6be9 = {
+    [exports.ChainId.ETHEREUM]: {
+        chainIdHex: "0x1",
+        chainName: "Ethereum",
+        rpcUrls: [
+            "https://mainnet.infura.io/v3/"
+        ],
+        nativeCurrency: {
+            name: "Ethereum",
+            symbol: "ETH",
+            decimals: 18
+        },
+        blockExplorerUrls: [
+            "https://etherscan.io/"
+        ]
+    },
+    [exports.ChainId.GOERLI]: {
+        chainIdHex: "0x5",
+        chainName: "Goerli",
+        rpcUrls: [
+            "https://goerli.infura.io/v3/"
+        ],
+        nativeCurrency: {
+            name: "Goerli Eth",
+            symbol: "ETH",
+            decimals: 18
+        },
+        blockExplorerUrls: [
+            "https://goerli.etherscan.io/"
+        ]
+    },
+    [exports.ChainId.POLYGON]: {
+        chainIdHex: "0x89",
+        chainName: "Polygon",
+        rpcUrls: [
+            "https://polygon-rpc.com"
+        ],
+        nativeCurrency: {
+            name: "MATIC",
+            symbol: "MATIC",
+            decimals: 18
+        },
+        blockExplorerUrls: [
+            "https://polygonscan.com/"
+        ]
+    }
+};
+exports.NetworkFilterTypes = void 0;
+(function(NetworkFilterTypes) {
+    NetworkFilterTypes["ALL"] = "all";
+})(exports.NetworkFilterTypes || (exports.NetworkFilterTypes = {}));
+
+
+exports.TokenFilterTypes = void 0;
+(function(TokenFilterTypes) {
+    TokenFilterTypes["SWAP"] = "swap";
+    TokenFilterTypes["BRIDGE"] = "bridge";
+    TokenFilterTypes["ALL"] = "all";
+})(exports.TokenFilterTypes || (exports.TokenFilterTypes = {}));
+
+
+
+
+const $4f91c5f280efe242$export$a130407f3423b97d = {
+    CHECK_CONNECTION: "eth_accounts",
+    CONNECT: "eth_requestAccounts",
+    ADD_NETWORK: "wallet_addEthereumChain",
+    SWITCH_NETWORK: "wallet_switchEthereumChain"
+};
+exports.WalletFilterTypes = void 0;
+(function(WalletFilterTypes) {
+    WalletFilterTypes["ALL"] = "all";
+    WalletFilterTypes["DESKTOP"] = "desktop";
+    WalletFilterTypes["MOBILE"] = "mobile";
+})(exports.WalletFilterTypes || (exports.WalletFilterTypes = {}));
+
+
+
+
+/**
+ * The different types of errors that can be returned by the checkout process.
+ */ exports.CheckoutErrorType = void 0;
+(function(CheckoutErrorType) {
+    CheckoutErrorType["PROVIDER_PREFERENCE_ERROR"] = "PROVIDER_PREFERENCE_ERROR";
+    CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
+    CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
+    CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_ERROR";
+    CheckoutErrorType["GET_NETWORK_INFO_ERROR"] = "GET_NETWORK_INFO_ERROR";
+    CheckoutErrorType["METAMASK_PROVIDER_ERROR"] = "METAMASK_PROVIDER_ERROR";
+    CheckoutErrorType["CHAIN_NOT_SUPPORTED_ERROR"] = "CHAIN_NOT_SUPPORTED_ERROR";
+    CheckoutErrorType["PROVIDER_REQUEST_MISSING_ERROR"] = "PROVIDER_REQUEST_MISSING_ERROR";
+    CheckoutErrorType["PROVIDER_REQUEST_FAILED_ERROR"] = "PROVIDER_REQUEST_FAILED_ERROR";
+    CheckoutErrorType["USER_REJECTED_REQUEST_ERROR"] = "USER_REJECTED_REQUEST_ERROR";
+    CheckoutErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
+})(exports.CheckoutErrorType || (exports.CheckoutErrorType = {}));
+class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
+    constructor(message, type, data){
+        super(message);
+        this.message = message;
+        this.type = type;
+        this.data = data;
+    }
+}
+let $a8bc256d81a5e2c1$export$a22d4e0719ee6def;
+(function(CheckoutInternalErrorType) {
+    CheckoutInternalErrorType["REJECTED_SWITCH_AFTER_ADDING_NETWORK"] = "REJECTED_SWITCH_AFTER_ADDING_NETWORK";
+})($a8bc256d81a5e2c1$export$a22d4e0719ee6def || ($a8bc256d81a5e2c1$export$a22d4e0719ee6def = {}));
+const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
+    try {
+        return await fn();
+    } catch (error) {
+        const cause = `${error.message}` || "UnknownError";
+        const errorMessage = customError.message ? `[${customError.type}]:${customError.message}. Cause:${cause}` : `[${customError.type}] Cause:${cause}`;
+        if (error instanceof $a8bc256d81a5e2c1$export$b722478a3cbfa3bc) throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
+            ...customError.data,
+            innerErrorType: error.type,
+            ...error.data
+        });
+        throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
+            ...customError.data
+        });
+    }
+};
+
+
+
+
+/* eslint-disable @typescript-eslint/no-explicit-any */ 
+
+/* eslint-disable @typescript-eslint/no-explicit-any */ 
+
+
+
+async function $c99672cf2294e839$export$2d040992269b4717(providerPreference) {
+    const provider = await $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference);
+    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
+        details: `Unsupported provider for ${providerPreference}`
+    });
+    let accounts = [];
+    try {
+        accounts = await provider.provider.request({
+            method: (0, $4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION,
+            params: []
+        });
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Check wallet connection request failed`, (exports.CheckoutErrorType).PROVIDER_REQUEST_FAILED_ERROR, {
+            rpcMethod: ($4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION
+        });
+    }
+    // accounts[0] will have the active account if connected.
+    return {
+        isConnected: accounts && accounts.length > 0,
+        walletAddress: accounts[0] ?? ""
+    };
+}
+async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
+    const web3Provider = await $c99672cf2294e839$var$getWalletProviderForPreference(params.providerPreference);
+    await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        if (!web3Provider || !web3Provider?.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
+            details: `Unsupported provider for ${params.providerPreference}`
+        });
+        // this makes the request to the wallet to connect i.e request eth accounts ('eth_requestAccounts')
+        await web3Provider.provider.request({
+            method: ($4f91c5f280efe242$export$a130407f3423b97d).CONNECT,
+            params: []
+        });
+    }, {
+        type: (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR
+    });
+    return web3Provider;
+}
+async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
+    let web3Provider = null;
+    switch(providerPreference){
+        case (exports.ConnectionProviders).METAMASK:
+            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
+            break;
+        default:
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
+    }
+    return web3Provider;
+}
+async function $c99672cf2294e839$var$getMetaMaskProvider() {
+    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        return await (detectEthereumProvider)();
+    }, {
+        type: (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR
+    });
+    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", (exports.CheckoutErrorType).METAMASK_PROVIDER_ERROR);
+    return new (providers.Web3Provider)(provider);
+}
+
+
+var $497c134ecbc8a50f$exports = {};
+$497c134ecbc8a50f$exports = JSON.parse('[{"chainId":1},{"chainId":137}]');
+
+
+const $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE = 4902; // error code (MetaMask)
+async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider) {
+    return ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        const network = await provider.getNetwork();
+        if (!Object.values((exports.ChainId)).includes(network.chainId)) // return empty details
+        return {
+            chainId: network.chainId,
+            name: network.name,
+            isSupported: false
+        };
+        const chainIdNetworkInfo = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[network.chainId];
+        return {
+            name: chainIdNetworkInfo.chainName,
+            chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
+            nativeCurrency: chainIdNetworkInfo.nativeCurrency,
+            isSupported: true
+        };
+    }, {
+        type: (exports.CheckoutErrorType).GET_NETWORK_INFO_ERROR
+    });
+}
+async function $de192de6ef100f9f$export$b827d9418aeb5dbd(providerPreference, provider, chainId) {
+    let currentProvider = provider;
+    if (!Object.values((exports.ChainId)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${chainId} is not a supported chain`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR);
+    if (!currentProvider || !currentProvider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR, {
+        details: `Unsupported provider`
+    });
+    // WT-1146 - Refer to the README in this folder for explantion on the switch network flow
+    try {
+        await $de192de6ef100f9f$var$switchNetworkInWallet(currentProvider, chainId);
+    } catch (err) {
+        if (err.code === $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE) try {
+            await $de192de6ef100f9f$var$addNetworkToWallet(currentProvider, chainId);
+        } catch (err) {
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled add network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
+        }
+        else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
+    }
+    currentProvider = await ($c99672cf2294e839$export$fba2f6c3656e07c1)({
+        providerPreference: providerPreference
+    });
+    if ((await currentProvider.getNetwork()).chainId !== chainId) // user didn't actually switch
+    throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", (exports.CheckoutErrorType).USER_REJECTED_REQUEST_ERROR);
+    // we can assume that if the above succeeds then user has successfully
+    // switched to the network specified
+    const newNetwork = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId];
+    return {
+        network: {
+            name: newNetwork.chainName,
+            chainId: parseInt(newNetwork.chainIdHex, 16),
+            nativeCurrency: newNetwork.nativeCurrency
+        },
+        provider: currentProvider
+    };
+}
+async function $de192de6ef100f9f$export$3043f6442a9ef563({ type: type = (exports.NetworkFilterTypes).ALL , exclude: exclude  }) {
+    const list = ((/*@__PURE__*/$parcel$interopDefault($497c134ecbc8a50f$exports))).filter((network)=>{
+        const allowAllTokens = type === (exports.NetworkFilterTypes).ALL;
+        const networkNotExcluded = !(exclude || []).map((exc)=>exc.chainId).includes(network.chainId);
+        return allowAllTokens && networkNotExcluded;
+    });
+    const allowedNetworks = [];
+    list.forEach((element)=>{
+        const newNetwork = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[element.chainId];
+        allowedNetworks.push({
+            name: newNetwork.chainName,
+            chainId: parseInt(newNetwork.chainIdHex, 16),
+            nativeCurrency: newNetwork.nativeCurrency,
+            isSupported: true
+        });
+    });
+    return {
+        networks: allowedNetworks
+    };
+}
+// these functions should not be exported. These functions should be used as part of an exported function e.g switchWalletNetwork() above.
+// make sure to check if(provider.provider?.request) in the exported function and throw an error
+async function $de192de6ef100f9f$var$switchNetworkInWallet(provider, chainId) {
+    if (provider.provider?.request) return await provider.provider.request({
+        method: ($4f91c5f280efe242$export$a130407f3423b97d).SWITCH_NETWORK,
+        params: [
+            {
+                chainId: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainIdHex
+            }
+        ]
+    });
+}
+async function $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId) {
+    if (provider.provider?.request) {
+        const addNetwork = {
+            chainId: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainIdHex,
+            chainName: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainName,
+            rpcUrls: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].rpcUrls,
+            nativeCurrency: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].nativeCurrency,
+            blockExplorerUrls: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].blockExplorerUrls
+        };
+        return await provider.provider.request({
+            method: ($4f91c5f280efe242$export$a130407f3423b97d).ADD_NETWORK,
+            params: [
+                addNetwork
+            ]
+        });
+    }
+}
+
+
+
+
+
+var $cda6003506e4182e$exports = {};
+$cda6003506e4182e$exports = JSON.parse("[{\"address\":\"0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0\",\"chainId\":137,\"name\":\"Matic\",\"symbol\":\"MATIC\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 38.4 33.5' style='enable-background:new 0 0 38.4 33.5;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bfill:%238247E5;%7D%0A%3C/style%3E%3Cg%3E%3Cpath class='st0' d='M29,10.2c-0.7-0.4-1.6-0.4-2.4,0L21,13.5l-3.8,2.1l-5.5,3.3c-0.7,0.4-1.6,0.4-2.4,0L5,16.3 c-0.7-0.4-1.2-1.2-1.2-2.1v-5c0-0.8,0.4-1.6,1.2-2.1l4.3-2.5c0.7-0.4,1.6-0.4,2.4,0L16,7.2c0.7,0.4,1.2,1.2,1.2,2.1v3.3l3.8-2.2V7 c0-0.8-0.4-1.6-1.2-2.1l-8-4.7c-0.7-0.4-1.6-0.4-2.4,0L1.2,5C0.4,5.4,0,6.2,0,7v9.4c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l5.5-3.2l3.8-2.2l5.5-3.2c0.7-0.4,1.6-0.4,2.4,0l4.3,2.5c0.7,0.4,1.2,1.2,1.2,2.1v5c0,0.8-0.4,1.6-1.2,2.1 L29,28.8c-0.7,0.4-1.6,0.4-2.4,0l-4.3-2.5c-0.7-0.4-1.2-1.2-1.2-2.1V21l-3.8,2.2v3.3c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l8.1-4.7c0.7-0.4,1.2-1.2,1.2-2.1V17c0-0.8-0.4-1.6-1.2-2.1L29,10.2z'/%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"name\":\"Ethereum\",\"symbol\":\"ETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"chainId\":1,\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF\",\"chainId\":1,\"name\":\"Immutable X\",\"symbol\":\"IMX\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0\",\"chainId\":1,\"name\":\"Matic\",\"symbol\":\"MATIC\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 38.4 33.5' style='enable-background:new 0 0 38.4 33.5;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bfill:%238247E5;%7D%0A%3C/style%3E%3Cg%3E%3Cpath class='st0' d='M29,10.2c-0.7-0.4-1.6-0.4-2.4,0L21,13.5l-3.8,2.1l-5.5,3.3c-0.7,0.4-1.6,0.4-2.4,0L5,16.3 c-0.7-0.4-1.2-1.2-1.2-2.1v-5c0-0.8,0.4-1.6,1.2-2.1l4.3-2.5c0.7-0.4,1.6-0.4,2.4,0L16,7.2c0.7,0.4,1.2,1.2,1.2,2.1v3.3l3.8-2.2V7 c0-0.8-0.4-1.6-1.2-2.1l-8-4.7c-0.7-0.4-1.6-0.4-2.4,0L1.2,5C0.4,5.4,0,6.2,0,7v9.4c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l5.5-3.2l3.8-2.2l5.5-3.2c0.7-0.4,1.6-0.4,2.4,0l4.3,2.5c0.7,0.4,1.2,1.2,1.2,2.1v5c0,0.8-0.4,1.6-1.2,2.1 L29,28.8c-0.7,0.4-1.6,0.4-2.4,0l-4.3-2.5c-0.7-0.4-1.2-1.2-1.2-2.1V21l-3.8,2.2v3.3c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l8.1-4.7c0.7-0.4,1.2-1.2,1.2-2.1V17c0-0.8-0.4-1.6-1.2-2.1L29,10.2z'/%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"name\":\"Ethereum\",\"symbol\":\"ETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"chainId\":5,\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x1facdd0165489f373255a90304650e15481b2c85\",\"chainId\":5,\"name\":\"Immutable X\",\"symbol\":\"IMX\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x123456789\",\"chainId\":5,\"name\":\"Swap Coin\",\"symbol\":\"SWC\",\"decimals\":18,\"tokenFeatures\":[\"swap\",\"fakeFeature\"]},{\"address\":\"0x123456789\",\"chainId\":5,\"name\":\"Bridge Coin\",\"symbol\":\"BDC\",\"decimals\":18,\"tokenFeatures\":[\"bridge\",\"fakeFeature\"]}]");
+
+
+const $efe60cea83bfc4e8$export$473cec51305fdae8 = async function({ type: type = (exports.TokenFilterTypes).ALL , chainId: chainId , exclude: exclude  }) {
+    // todo:For API call, use the CheckoutError with errorType:API_CALL_ERROR?? or any other
+    const filteredTokenList = ((/*@__PURE__*/$parcel$interopDefault($cda6003506e4182e$exports))).filter((token)=>{
+        const chainIdMatches = token.chainId == chainId;
+        const tokenNotExcluded = !exclude?.map((excludeToken)=>excludeToken.address).includes(token.address || "");
+        const allowAllTokens = type === (exports.TokenFilterTypes).ALL;
+        const tokenAllowedForType = token.tokenFeatures.includes(type);
+        return chainIdMatches && tokenNotExcluded && (allowAllTokens || tokenAllowedForType);
+    }).map((token)=>{
+        const { chainId: chainId , tokenFeatures: tokenFeatures , ...tokenInfo } = token;
+        return tokenInfo;
+    });
+    return {
+        tokens: filteredTokenList
+    };
+};
+
+
+
+
+const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (provider, walletAddress)=>{
+    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        const networkInfo = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(provider);
+        if (!networkInfo.isSupported) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${networkInfo.chainId} is not a supported chain`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR, {
+            chainName: networkInfo.name
+        });
+        const balance = await provider.getBalance(walletAddress);
+        return {
+            balance: balance,
+            formattedBalance: (ethers.utils).formatUnits(balance, networkInfo.nativeCurrency.decimals),
+            token: networkInfo.nativeCurrency
+        };
+    }, {
+        type: (exports.CheckoutErrorType).GET_BALANCE_ERROR
+    });
+};
+async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress, contractAddress) {
+    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        const contract = new (ethers.Contract)(contractAddress, JSON.stringify(($762782b6c862d954$export$db5daa1b5156ccfe)), provider);
+        const name = await contract.name();
+        const symbol = await contract.symbol();
+        const balance = await contract.balanceOf(walletAddress);
+        const decimals = await contract.decimals();
+        const formattedBalance = (ethers.utils).formatUnits(balance, decimals);
+        return {
+            balance: balance,
+            formattedBalance: formattedBalance,
+            token: {
+                name: name,
+                symbol: symbol,
+                decimals: decimals,
+                address: contractAddress
+            }
+        };
+    }, {
+        type: (exports.CheckoutErrorType).GET_ERC20_BALANCE_ERROR
+    });
+}
+const $1564e43dde50bb61$export$fee49741664a4d7e = async (provider, walletAddress, chainId)=>{
+    if (!Object.values((exports.ChainId)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`ChainId ${chainId} is not supported`, (exports.CheckoutErrorType).CHAIN_NOT_SUPPORTED_ERROR);
+    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("provider object is missing request function", (exports.CheckoutErrorType).PROVIDER_REQUEST_MISSING_ERROR);
+    const tokenList = await ($efe60cea83bfc4e8$export$473cec51305fdae8)({
+        type: (exports.TokenFilterTypes).ALL,
+        chainId: chainId
+    });
+    const allBalancePromises = [];
+    allBalancePromises.push($1564e43dde50bb61$export$df96cd8d56be0ab1(provider, walletAddress));
+    tokenList.tokens.filter((token)=>token.address).forEach((token)=>allBalancePromises.push($1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress, token.address ?? "")));
+    const balanceResults = await Promise.allSettled(allBalancePromises);
+    const getBalanceResults = balanceResults.filter((result)=>result.status === "fulfilled").map((fulfilledResult)=>fulfilledResult.value);
+    return {
+        balances: getBalanceResults
+    };
+};
+
+
+
+
+
+
+
+
+
+var $6f3c55a615003cbf$exports = {};
+$6f3c55a615003cbf$exports = JSON.parse('[{"connectionProvider":"metamask","icon":"some-icon-url","name":"MetaMask","description":"complete web3 wallet solution","platform":["desktop"]},{"connectionProvider":"passport","icon":"pp-icon","name":"Passport","description":"Web3 with your email!","platform":["mobile","desktop"]},{"connectionProvider":"gamestop","icon":"gme-icon","name":"GameStop","description":"Never stopping the game!","platform":["mobile"]}]');
+
+
+async function $5cdde2ffe6360fec$export$a822caa90d7eef09({ type: type = (exports.WalletFilterTypes).ALL , exclude: exclude  }) {
+    // todo:For async API call, use the CheckoutError with errorType:API_CALL_ERROR?? or any other
+    const filteredWalletsList = ((/*@__PURE__*/$parcel$interopDefault($6f3c55a615003cbf$exports))).filter((wallet)=>{
+        const walletNotExcluded = !exclude?.map((excludeWallet)=>excludeWallet.connectionProvider).includes(wallet.connectionProvider);
+        const allowAllWallets = type === (exports.WalletFilterTypes).ALL;
+        const walletsAllowedForType = wallet.platform.includes(type);
+        return walletNotExcluded && (allowAllWallets || walletsAllowedForType);
+    }).map((wallet)=>{
+        const { platform: platform , ...walletInfo } = wallet;
+        return walletInfo;
+    });
+    return {
+        wallets: filteredWalletsList
+    };
+}
+
+
+
+
+
+
+const $dbe95599a4661140$export$8e0e7ffc78696d30 = async (params)=>{
+    const { provider: provider , transaction: transaction  } = params;
+    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        const transactionResponse = await provider.getSigner().sendTransaction(transaction);
+        return {
+            transactionResponse: transactionResponse
+        };
+    }, {
+        type: (exports.CheckoutErrorType).TRANSACTION_ERROR
+    });
+};
+
+
+
+
+
+class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
+    /**
+   * Check if a wallet is connected to the current application without requesting permission from the wallet and hence triggering a connect popup.
+   * @param {CheckConnectionParams} params - The necessary data required to verify a wallet connection status.
+   * @returns Wallet connection status details.
+   * @throws {@link ErrorType}
+   */ async checkIsWalletConnected(params) {
+        return $c99672cf2294e839$export$2d040992269b4717(params.providerPreference);
+    }
+    /**
+   * Establish a connection with a wallet provider such as MetaMask and returns the provider object and the current network details.
+   * @param {ConnectParams} params - The necessary data required to establish a connection with a wallet provider.
+   * @returns Wallet provider and current network information.
+   * @throws {@link ErrorType}
+   */ async connect(params) {
+        this.providerPreference = params.providerPreference;
+        const provider = await $c99672cf2294e839$export$fba2f6c3656e07c1(params);
+        const networkInfo = await $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider);
+        return {
+            provider: provider,
+            network: networkInfo
+        };
+    }
+    /**
+   * Switch the currently connected wallet to a new network.
+   * @param {SwitchNetworkParams} params - The necessary data required to switch network.
+   * @returns The new network information.
+   * @throws {@link ErrorType}
+   */ async switchNetwork(params) {
+        if (!this.providerPreference) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`connect should be called before switchNetwork to set the provider preference`, (exports.CheckoutErrorType).PROVIDER_PREFERENCE_ERROR);
+        return await $de192de6ef100f9f$export$b827d9418aeb5dbd(this.providerPreference, params.provider, params.chainId);
+    }
+    /**
+   * Fetch the balance of the native token of the current connected network or, if a contract address is provided, it will return the balance of that ERC20 token. For example, if the wallet is connected to the Ethereum Mainnet then the function gets the wallet ETH L1 balance.
+   * @param {GetBalanceParams} params - The necessary data required to fetch the wallet balance.
+   * @returns Native token balance for the given wallet.
+   * @throws {@link ErrorType}
+   */ async getBalance(params) {
+        if (!params.contractAddress || params.contractAddress === "") return await $1564e43dde50bb61$export$df96cd8d56be0ab1(params.provider, params.walletAddress);
+        return await $1564e43dde50bb61$export$60e0fe116a0e6ed0(params.provider, params.walletAddress, params.contractAddress);
+    }
+    /**
+   * Fetch all available balances (ERC20 & Native) of the current connected network of the given wallet. It will loop through the list of allowed tokens and check for balance on each one.
+   * @param {GetAllBalancesParams} params - The necessary data required to fetch all the wallet balances.
+   * @returns List of tokens balance for the given wallet.
+   * @throws {@link ErrorType}
+   */ async getAllBalances(params) {
+        return $1564e43dde50bb61$export$fee49741664a4d7e(params.provider, params.walletAddress, params.chainId);
+    }
+    /**
+   * Fetch the list of available networks that a wallet can add or/and switch to.
+   * @param {GetNetworkAllowListParams} params - The necessary data required to fetch the list of available networks.
+   * @returns List of networks.
+   * @throws {@link ErrorType}
+   */ async getNetworkAllowList(params) {
+        return await $de192de6ef100f9f$export$3043f6442a9ef563(params);
+    }
+    /**
+   * Get the list of tokens which are allowed to be used with the product.
+   * @param {GetTokenAllowListParams} params - The necessary data required to fetch the list of allowed tokens.
+   * @returns List of allowed tokens.
+   * @throws {@link ErrorType}
+   */ async getTokenAllowList(params) {
+        return await $efe60cea83bfc4e8$export$473cec51305fdae8(params);
+    }
+    /**
+   * Fetch the list of wallets which are available to connect with.
+   * @param {GetWalletAllowListParams} params - The necessary data required to fetch the list of allowed wallets.
+   * @returns List of allowed wallets.
+   * @throws {@link ErrorType}
+   */ async getWalletAllowList(params) {
+        return await $5cdde2ffe6360fec$export$a822caa90d7eef09(params);
+    }
+    /**
+   * Send a generic transaction to the provider.
+   * @param {SendTransactionParams} params - The necessary data required to send a transaction.
+   * @returns Transaction response.
+   * @throws {@link ErrorType}
+   * @remarks
+   * Further documenation can be found at [MetaMask | Sending Transactions](https://docs.metamask.io/guide/sending-transactions.html).
+   */ async sendTransaction(params) {
+        return await $dbe95599a4661140$export$8e0e7ffc78696d30(params);
+    }
+    /**
+   * Get network information about the currently selected network.
+   * @param {GetNetworkParams} params - The necessary data required to get the current network information.
+   * @returns Network details.
+   * @throws {@link ErrorType}
+   */ async getNetworkInfo(params) {
+        return await $de192de6ef100f9f$export$79f13b4cfaaf0d09(params.provider);
+    }
+}
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $88e4c575901cd68c$exports = {};
+
+$parcel$export($88e4c575901cd68c$exports, "IMTBLWidgetEvents", () => exports.IMTBLWidgetEvents);
+exports.IMTBLWidgetEvents = void 0;
+(function(IMTBLWidgetEvents) {
+    IMTBLWidgetEvents["IMTBL_CONNECT_WIDGET_EVENT"] = "imtbl-connect-widget";
+    IMTBLWidgetEvents["IMTBL_WALLET_WIDGET_EVENT"] = "imtbl-wallet-widget";
+    IMTBLWidgetEvents["IMTBL_SWAP_WIDGET_EVENT"] = "imtbl-swap-widget";
+    IMTBLWidgetEvents["IMTBL_BRIDGE_WIDGET_EVENT"] = "imtbl-bridge-widget";
+    IMTBLWidgetEvents["IMTBL_BUY_WIDGET_EVENT"] = "imtbl-buy-widget";
+})(exports.IMTBLWidgetEvents || (exports.IMTBLWidgetEvents = {}));
+
+
+var $d71a87afc3136184$exports = {};
+
+$parcel$export($d71a87afc3136184$exports, "ConnectEventType", () => exports.ConnectEventType);
+exports.ConnectEventType = void 0;
+(function(ConnectEventType) {
+    ConnectEventType["SUCCESS"] = "success";
+    ConnectEventType["FAILURE"] = "failure";
+    ConnectEventType["CLOSE_WIDGET"] = "close-widget";
+})(exports.ConnectEventType || (exports.ConnectEventType = {}));
+
+
+var $9d0f1783d4d36e8a$exports = {};
+
+$parcel$export($9d0f1783d4d36e8a$exports, "WalletEventType", () => exports.WalletEventType);
+//wallet widget events
+exports.WalletEventType = void 0;
+(function(WalletEventType) {
+    WalletEventType["CLOSE_WIDGET"] = "close-widget";
+    WalletEventType["NETWORK_SWITCH"] = "network-switch";
+})(exports.WalletEventType || (exports.WalletEventType = {}));
+
+
+var $5d497088f13bb116$exports = {};
+
+$parcel$export($5d497088f13bb116$exports, "SwapEventType", () => exports.SwapEventType);
+exports.SwapEventType = void 0;
+(function(SwapEventType) {
+    SwapEventType["SUCCESS"] = "success";
+    SwapEventType["FAILURE"] = "failure";
+})(exports.SwapEventType || (exports.SwapEventType = {}));
+
+
+var $28a5fdc2f5e6c742$exports = {};
+
+$parcel$export($28a5fdc2f5e6c742$exports, "BridgeEventType", () => exports.BridgeEventType);
+exports.BridgeEventType = void 0;
+(function(BridgeEventType) {
+    BridgeEventType["CLOSE_WIDGET"] = "close-widget";
+    BridgeEventType["SUCCESS"] = "success";
+    BridgeEventType["FAILURE"] = "failure";
+})(exports.BridgeEventType || (exports.BridgeEventType = {}));
+
+
+var $ede253beebe0de4a$exports = {};
+
+$parcel$export($ede253beebe0de4a$exports, "BuyEventType", () => exports.BuyEventType);
+exports.BuyEventType = void 0;
+(function(BuyEventType) {
+    BuyEventType["SUCCESS"] = "success";
+    BuyEventType["FAILURE"] = "failure";
+    BuyEventType["NOT_CONNECTED"] = "not_connected";
+    BuyEventType["CLOSE"] = "close";
+})(exports.BuyEventType || (exports.BuyEventType = {}));
+
+
+var $9234b4c577442a97$exports = {};
+
+$parcel$export($9234b4c577442a97$exports, "Network", () => exports.Network);
+$parcel$export($9234b4c577442a97$exports, "WidgetTheme", () => exports.WidgetTheme);
+$parcel$export($9234b4c577442a97$exports, "ConnectionProviders", () => exports.ConnectionProviders);
+
+exports.Network = void 0;
+(function(Network) {
+    Network["ETHEREUM"] = "Ethereum";
+    Network["GOERLI"] = "Goerli";
+    Network["POLYGON"] = "Polygon";
+})(exports.Network || (exports.Network = {}));
+exports.WidgetTheme = void 0;
+(function(WidgetTheme) {
+    WidgetTheme["LIGHT"] = "light";
+    WidgetTheme["DARK"] = "dark";
+    WidgetTheme["CUSTOM"] = "custom";
+})(exports.WidgetTheme || (exports.WidgetTheme = {}));
+
 Object.defineProperty(exports, 'imxClientCreateStarkSigner', {
     enumerable: true,
     get: function () { return coreSdk.createStarkSigner; }
@@ -1469,7 +3219,11 @@ Object.defineProperty(exports, 'imxClientGenerateLegacyStarkPrivateKey', {
     enumerable: true,
     get: function () { return coreSdk.generateLegacyStarkPrivateKey; }
 });
+exports.Checkout = $a8cb37a3fc8eb863$export$1f60ba4ec72508a0;
+exports.GenericIMXProvider = GenericIMXProvider;
 exports.ImmutableConfiguration = ImmutableConfiguration;
 exports.ImmutableXClient = ImmutableXClient;
+exports.MetaMaskIMXProvider = MetaMaskIMXProvider;
 exports.Passport = Passport;
 exports.PassportError = PassportError;
+exports.ProviderConfiguration = ProviderConfiguration;