@imtbl/sdk 0.0.1-alpha

package/dist/index.cjs

@@ -0,0 +1,2576 @@
+'use strict';
+
+var coreSdk = require('@imtbl/core-sdk');
+var BN = require('bn.js');
+var encUtils = require('enc-utils');
+var units = require('@ethersproject/units');
+var bignumber = require('@ethersproject/bignumber');
+var ethers = require('ethers');
+var detectEthereumProvider = require('@metamask/detect-provider');
+var oidcClientTs = require('oidc-client-ts');
+var magicSdk = require('magic-sdk');
+var oidc = require('@magic-ext/oidc');
+var providers = require('@ethersproject/providers');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var encUtils__namespace = /*#__PURE__*/_interopNamespaceDefault(encUtils);
+
+exports.Environment = void 0;
+(function (Environment) {
+    Environment["PRODUCTION"] = "production";
+    Environment["SANDBOX"] = "sandbox";
+})(exports.Environment || (exports.Environment = {}));
+class ImmutableConfiguration {
+    environment;
+    apiKey;
+    constructor(options) {
+        this.environment = options.environment;
+        this.apiKey = options.apiKey;
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const StarkExAPIFactory = (config) => {
+    const imtblClient = new coreSdk.ImmutableX(config.immutableXConfig);
+    const { deposit, registerOffchain, isRegisteredOnchain, prepareWithdrawal, completeWithdrawal, createOrder, cancelOrder, createTrade, transfer, batchNftTransfer, ...StarkEx } = imtblClient;
+    return { ...StarkEx };
+};
+
+// used to sign message with L1 keys. Used for registration
+function serializeEthSignature(sig) {
+    // This is because golang appends a recovery param
+    // https://github.com/ethers-io/ethers.js/issues/823
+    return encUtils__namespace.addHexPrefix(encUtils__namespace.padLeft(sig.r.toString(16), 64) +
+        encUtils__namespace.padLeft(sig.s.toString(16), 64) +
+        encUtils__namespace.padLeft(sig.recoveryParam?.toString(16) || '', 2));
+}
+function importRecoveryParam(v) {
+    return v.trim()
+        ? new BN(v, 16).cmp(new BN(27)) !== -1
+            ? new BN(v, 16).sub(new BN(27)).toNumber()
+            : new BN(v, 16).toNumber()
+        : undefined;
+}
+// used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
+function deserializeSignature(sig, size = 64) {
+    sig = encUtils__namespace.removeHexPrefix(sig);
+    return {
+        r: new BN(sig.substring(0, size), 'hex'),
+        s: new BN(sig.substring(size, size * 2), 'hex'),
+        recoveryParam: importRecoveryParam(sig.substring(size * 2, size * 2 + 2)),
+    };
+}
+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
+ * @param token - the token type to convert to a SignableToken type
+ * @returns the converted SignableToken
+ */
+function convertToSignableToken(token) {
+    switch (token.type) {
+        case 'ERC721':
+            return {
+                type: 'ERC721',
+                data: {
+                    token_id: token.tokenId,
+                    token_address: token.tokenAddress,
+                },
+            };
+        case 'ERC20':
+            return {
+                type: 'ERC20',
+                data: {
+                    token_address: token.tokenAddress,
+                },
+            };
+        case 'ETH':
+            return {
+                type: 'ETH',
+                data: {
+                    decimals: 18,
+                },
+            };
+    }
+}
+
+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$1({ signers: { ethSigner, starkExSigner }, 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 starkExSigner.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, starkExSigner }, 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 starkExSigner.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$1({ 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.starkExSigner.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$1({ 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.starkExSigner.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.starkExSigner.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.starkExSigner.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, starkExSigner }, 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 starkExSigner.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 starkExConfig = config.immutableXConfig;
+    const usersApi = new coreSdk.UsersApi(starkExConfig.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 starkExConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC20', starkExConfig, {
+        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, starkExConfig);
+    }
+}
+
+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 starkExConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', starkExConfig, {
+        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, starkExConfig);
+    }
+    else {
+        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, starkExConfig);
+    }
+}
+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 starkExConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC721', starkExConfig, {
+        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, starkExConfig);
+    }
+    else {
+        return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, starkExConfig);
+    }
+}
+async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const tokenAddress = token.tokenAddress;
+    const tokenId = token.tokenId;
+    const starkExConfig = config.immutableXConfig;
+    const mintsApi = new coreSdk.MintsApi(starkExConfig.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 starkExConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ETH', starkExConfig);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+    }
+    else {
+        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+    }
+}
+
+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$1({ signers: { ethSigner, starkExSigner }, 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 starkExSigner.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 starkExConfig = config.immutableXConfig;
+    const depositsApi = new coreSdk.DepositsApi(starkExConfig.apiConfiguration);
+    const encodingApi = new coreSdk.EncodingApi(starkExConfig.apiConfiguration);
+    const usersApi = new coreSdk.UsersApi(starkExConfig.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, starkExConfig, usersApi);
+    }
+    else {
+        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, starkExConfig);
+    }
+}
+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$1({ 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.starkExSigner.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, starkExSigner) {
+        this.config = config;
+        this.signers = { ethSigner, starkExSigner };
+    }
+    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$1({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
+    }
+    completeWithdrawal(starkPublicKey, token) {
+        return completeWithdrawal({
+            config: this.config,
+            signers: this.signers,
+            token,
+            starkPublicKey,
+        });
+    }
+    createOrder(request) {
+        return createOrder$1({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
+    }
+    createTrade(request) {
+        return createTrade$1({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
+    }
+    deposit(tokenAmount) {
+        return deposit({
+            signers: this.signers,
+            deposit: tokenAmount,
+            config: this.config,
+        });
+    }
+    exchangeTransfer(request) {
+        return exchangeTransfer$1({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
+    }
+    async isRegisteredOnchain() {
+        const starkPublicKey = await this.signers.starkExSigner.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$1({
+            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, starkExSigner) {
+        super(config, ethSigner, starkExSigner);
+    }
+    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;
+                }
+            }
+        }
+    }
+}
+
+var PassportErrorType;
+(function (PassportErrorType) {
+    PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+    PassportErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
+    PassportErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
+    PassportErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
+    PassportErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
+    PassportErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
+    PassportErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
+    PassportErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
+    PassportErrorType["CREATE_ORDER_ERROR"] = "CREATE_ORDER_ERROR";
+    PassportErrorType["CANCEL_ORDER_ERROR"] = "CANCEL_ORDER_ERROR";
+    PassportErrorType["EXCHANGE_TRANSFER_ERROR"] = "EXCHANGE_TRANSFER_ERROR";
+    PassportErrorType["CREATE_TRADE_ERROR"] = "CREATE_TRADE_ERROR";
+    PassportErrorType["OPERATION_NOT_SUPPORTED_ERROR"] = "OPERATION_NOT_SUPPORTED_ERROR";
+})(PassportErrorType || (PassportErrorType = {}));
+class PassportError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
+    }
+}
+const withPassportError = async (fn, customErrorType) => {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        const errorMessage = `${customErrorType}: ${error.message}` || 'UnknownError';
+        throw new PassportError(errorMessage, customErrorType);
+    }
+};
+
+const POLL_INTERVAL = 1 * 1000; // every 1 second
+const MAX_RETRIES = 3;
+const wait = (ms) => new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+});
+const retryWithDelay = async (fn, options) => {
+    const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), } = options || {};
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (retries <= 0) {
+            return Promise.reject(finalErr);
+        }
+        await wait(interval);
+        return retryWithDelay(fn, { retries: retries - 1, finalErr });
+    }
+};
+
+const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
+    const baseConfiguration = {
+        authority: authenticationDomain,
+        redirect_uri: oidcConfiguration.redirectUri,
+        popup_redirect_uri: oidcConfiguration.redirectUri,
+        client_id: oidcConfiguration.clientId,
+        metadata: {
+            authorization_endpoint: `${authenticationDomain}/authorize`,
+            token_endpoint: `${authenticationDomain}/oauth/token`,
+            userinfo_endpoint: `${authenticationDomain}/userinfo`,
+            end_session_endpoint: `${authenticationDomain}/v2/logout` +
+                `?returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}` +
+                `&client_id=${oidcConfiguration.clientId}`,
+        },
+        mergeClaims: true,
+        loadUserInfo: true,
+        scope: oidcConfiguration.scope,
+    };
+    if (oidcConfiguration.audience) {
+        baseConfiguration.extraQueryParams = {
+            audience: oidcConfiguration.audience,
+        };
+    }
+    return baseConfiguration;
+};
+class AuthManager {
+    userManager;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.userManager = new oidcClientTs.UserManager(getAuthConfiguration(config));
+    }
+    mapOidcUserToDomainModel = (oidcUser) => {
+        const passport = oidcUser.profile?.passport;
+        return {
+            idToken: oidcUser.id_token,
+            accessToken: oidcUser.access_token,
+            refreshToken: oidcUser.refresh_token,
+            profile: {
+                sub: oidcUser.profile.sub,
+                email: oidcUser.profile.email,
+                nickname: oidcUser.profile.nickname,
+            },
+            etherKey: passport?.ether_key || '',
+        };
+    };
+    async login() {
+        return withPassportError(async () => {
+            const popupWindowFeatures = { width: 400, height: 420 };
+            const oidcUser = await this.userManager.signinPopup({
+                popupWindowFeatures,
+            });
+            return this.mapOidcUserToDomainModel(oidcUser);
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    async loginCallback() {
+        return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    async logout() {
+        return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
+    }
+    async getUser() {
+        return withPassportError(async () => {
+            const oidcUser = await this.userManager.getUser();
+            if (!oidcUser) {
+                throw new Error('Failed to retrieve user');
+            }
+            return this.mapOidcUserToDomainModel(oidcUser);
+        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
+    }
+    async requestRefreshTokenAfterRegistration() {
+        return withPassportError(async () => {
+            const updatedUser = await retryWithDelay(async () => {
+                const user = await this.userManager.signinSilent();
+                const passportMetadata = user?.profile?.passport;
+                const metadataExists = !!passportMetadata?.ether_key &&
+                    !!passportMetadata?.stark_key &&
+                    !!passportMetadata?.user_admin_key;
+                if (metadataExists) {
+                    return user;
+                }
+                return Promise.reject('user wallet addresses not exist');
+            });
+            if (!updatedUser) {
+                return null;
+            }
+            return this.mapOidcUserToDomainModel(updatedUser);
+        }, PassportErrorType.REFRESH_TOKEN_ERROR);
+    }
+}
+
+class MagicAdapter {
+    magicClient;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.magicClient = new magicSdk.Magic(config.magicPublishableApiKey, {
+            network: config.network,
+            extensions: [new oidc.OpenIdExtension()],
+        });
+    }
+    async login(idToken) {
+        return withPassportError(async () => {
+            await this.magicClient.openid.loginWithOIDC({
+                jwt: idToken,
+                providerId: this.config.magicProviderId,
+            });
+            return new ethers.ethers.providers.Web3Provider(this.magicClient
+                .rpcProvider);
+        }, PassportErrorType.WALLET_CONNECTION_ERROR);
+    }
+}
+
+var ReceiveMessage;
+(function (ReceiveMessage) {
+    ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
+    ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
+    ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
+})(ReceiveMessage || (ReceiveMessage = {}));
+var SendMessage;
+(function (SendMessage) {
+    SendMessage["TRANSACTION_START"] = "transaction_start";
+})(SendMessage || (SendMessage = {}));
+var TransactionTypes;
+(function (TransactionTypes) {
+    TransactionTypes["CancelOrder"] = "delete:v1/orders";
+    TransactionTypes["CreateOrder"] = "post:v1/orders";
+    TransactionTypes["CreateTrade"] = "post:v1/trades";
+    TransactionTypes["CreateTransfer"] = "post:v1/transfers";
+    TransactionTypes["CreateBatchTransfer"] = "post:v2/transfers";
+})(TransactionTypes || (TransactionTypes = {}));
+const PassportEventType = 'imx_passport_confirmation';
+
+const openPopupCenter = ({ url, title, width, height, }) => {
+    const left = Math.max(0, Math.round(window.screenX + (window.outerWidth - width) / 2));
+    const top = Math.max(0, Math.round(window.screenY + (window.outerHeight - height) / 2));
+    const newWindow = window.open(url, title, `
+      scrollbars=yes,
+      width=${width}, 
+      height=${height}, 
+      top=${top}, 
+      left=${left}
+     `);
+    if (!newWindow) {
+        throw new Error('Failed to open confirmation screen');
+    }
+    newWindow.focus();
+    return newWindow;
+};
+
+const ConfirmationWindowTitle = 'Confirm this transaction';
+const ConfirmationWindowHeight = 380;
+const ConfirmationWindowWidth = 480;
+const ConfirmationWindowClosedPollingDuration = 1000;
+class ConfirmationScreen {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    postMessage(destinationWindow, accessToken, message) {
+        destinationWindow.postMessage({
+            eventType: PassportEventType,
+            accessToken,
+            ...message,
+        }, this.config.passportDomain);
+    }
+    startTransaction(accessToken, transaction, popupOptions) {
+        return new Promise((resolve, reject) => {
+            const messageHandler = ({ data, origin }) => {
+                if (origin != this.config.passportDomain ||
+                    data.eventType != PassportEventType) {
+                    return;
+                }
+                switch (data.messageType) {
+                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
+                        this.postMessage(confirmationWindow, accessToken, {
+                            messageType: SendMessage.TRANSACTION_START,
+                            messageData: transaction,
+                        });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
+                        resolve({ confirmed: true });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_ERROR: {
+                        reject(new Error('Transaction error'));
+                        break;
+                    }
+                    default:
+                        reject(new Error('Unsupported message type'));
+                }
+            };
+            window.addEventListener('message', messageHandler);
+            const confirmationWindow = openPopupCenter({
+                url: `${this.config.passportDomain}/transaction-confirmation`,
+                title: ConfirmationWindowTitle,
+                width: popupOptions?.width || ConfirmationWindowWidth,
+                height: popupOptions?.height || ConfirmationWindowHeight,
+            });
+            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
+            const timer = setInterval(function () {
+                if (confirmationWindow.closed) {
+                    clearInterval(timer);
+                    window.removeEventListener('message', messageHandler);
+                    resolve({ confirmed: false });
+                }
+            }, ConfirmationWindowClosedPollingDuration);
+        });
+    }
+}
+
+const ERC721$1 = 'ERC721';
+const transfer = ({ request, transfersApi, starkSigner, user, passportConfig, }) => {
+    return withPassportError(async () => {
+        const transferAmount = request.type === ERC721$1 ? '1' : request.amount;
+        const getSignableTransferRequest = {
+            sender: user.etherKey,
+            token: convertToSignableToken(request),
+            amount: transferAmount,
+            receiver: request.receiver,
+        };
+        const signableResult = await transfersApi.getSignableTransferV1({
+            getSignableTransferRequest,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateTransfer,
+            transactionData: getSignableTransferRequest,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const signableResultData = signableResult.data;
+        const { payload_hash: payloadHash } = signableResultData;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const senderStarkKey = await starkSigner.getAddress();
+        const transferSigningParams = {
+            sender_stark_key: signableResultData.sender_stark_key || senderStarkKey,
+            sender_vault_id: signableResultData.sender_vault_id,
+            receiver_stark_key: signableResultData.receiver_stark_key,
+            receiver_vault_id: signableResultData.receiver_vault_id,
+            asset_id: signableResultData.asset_id,
+            amount: signableResultData.amount,
+            nonce: signableResultData.nonce,
+            expiration_timestamp: signableResultData.expiration_timestamp,
+            stark_signature: starkSignature,
+        };
+        const createTransferRequest = {
+            createTransferRequest: transferSigningParams,
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const { data: responseData } = await transfersApi.createTransferV1(createTransferRequest, { headers });
+        return {
+            sent_signature: responseData.sent_signature,
+            status: responseData.status?.toString(),
+            time: responseData.time,
+            transfer_id: responseData.transfer_id,
+        };
+    }, PassportErrorType.TRANSFER_ERROR);
+};
+async function batchNftTransfer({ user, starkSigner, request, transfersApi, passportConfig, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const signableRequests = request.map((nftTransfer) => {
+            return {
+                amount: '1',
+                token: convertToSignableToken({
+                    type: ERC721$1,
+                    tokenId: nftTransfer.tokenId,
+                    tokenAddress: nftTransfer.tokenAddress,
+                }),
+                receiver: nftTransfer.receiver,
+            };
+        });
+        const getSignableTransferRequestV2 = {
+            sender_ether_key: ethAddress,
+            signable_requests: signableRequests,
+        };
+        const signableResult = await transfersApi.getSignableTransfer({
+            getSignableTransferRequestV2,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const popupWindowSize = { width: 480, height: 784 };
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateBatchTransfer,
+            transactionData: getSignableTransferRequestV2,
+        }, popupWindowSize);
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
+            const starkSignature = await starkSigner.signMessage(resp.payload_hash);
+            return {
+                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,
+            };
+        }));
+        const transferSigningParams = {
+            sender_stark_key: signableResult.data.sender_stark_key,
+            requests,
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const response = await transfersApi.createTransfer({
+            createTransferRequestV2: transferSigningParams,
+        }, { headers });
+        return {
+            transfer_ids: response?.data.transfer_ids,
+        };
+    }, PassportErrorType.TRANSFER_ERROR);
+}
+
+const ERC721 = 'ERC721';
+async function createOrder({ starkSigner, user, request, ordersApi, passportConfig, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const amountSell = request.sell.type === ERC721 ? '1' : request.sell.amount;
+        const amountBuy = request.buy.type === ERC721 ? '1' : request.buy.amount;
+        const getSignableOrderRequestV3 = {
+            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,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateOrder,
+            transactionData: getSignableOrderRequestV3,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const { payload_hash: payloadHash } = getSignableOrderResponse.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const signableResultData = getSignableOrderResponse.data;
+        const orderParams = {
+            createOrderRequest: {
+                include_fees: true,
+                fees: request.fees,
+                stark_signature: starkSignature,
+                amount_buy: signableResultData.amount_buy,
+                amount_sell: signableResultData.amount_sell,
+                asset_id_buy: signableResultData.asset_id_buy,
+                asset_id_sell: signableResultData.asset_id_sell,
+                expiration_timestamp: signableResultData.expiration_timestamp,
+                nonce: signableResultData.nonce,
+                stark_key: signableResultData.stark_key,
+                vault_id_buy: signableResultData.vault_id_buy,
+                vault_id_sell: signableResultData.vault_id_sell,
+            },
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const createOrderResponse = await ordersApi.createOrder(orderParams, {
+            headers,
+        });
+        return {
+            ...createOrderResponse.data,
+        };
+    }, PassportErrorType.CREATE_ORDER_ERROR);
+}
+async function cancelOrder({ user, starkSigner, request, ordersApi, passportConfig, }) {
+    return withPassportError(async () => {
+        const getSignableCancelOrderRequest = {
+            order_id: request.order_id,
+        };
+        const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
+            getSignableCancelOrderRequest,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CancelOrder,
+            transactionData: getSignableCancelOrderRequest,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const cancelOrderResponse = await ordersApi.cancelOrder({
+            id: request.order_id.toString(),
+            cancelOrderRequest: {
+                order_id: request.order_id,
+                stark_signature: starkSignature,
+            },
+        }, { headers });
+        return {
+            order_id: cancelOrderResponse.data.order_id,
+            status: cancelOrderResponse.data.status,
+        };
+    }, PassportErrorType.CANCEL_ORDER_ERROR);
+}
+
+async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const transferAmount = request.amount;
+        const signableResult = await exchangesApi.getExchangeSignableTransfer({
+            id: request.transactionID,
+            getSignableTransferRequest: {
+                sender: ethAddress,
+                token: convertToSignableToken(request),
+                amount: transferAmount,
+                receiver: request.receiver,
+            },
+        });
+        const starkAddress = await starkSigner.getAddress();
+        const { payload_hash: payloadHash } = signableResult.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const transferSigningParams = {
+            sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
+            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 headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const response = await exchangesApi.createExchangeTransfer({
+            id: request.transactionID,
+            createTransferRequest: transferSigningParams,
+        }, { headers });
+        return {
+            sent_signature: response?.data.sent_signature,
+            status: response?.data.status?.toString(),
+            time: response?.data.time,
+            transfer_id: response?.data.transfer_id,
+        };
+    }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
+}
+
+async function createTrade({ request, tradesApi, user, starkSigner, passportConfig, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const getSignableTradeRequest = {
+            expiration_timestamp: request.expiration_timestamp,
+            fees: request.fees,
+            order_id: request.order_id,
+            user: ethAddress,
+        };
+        const getSignableTradeResponse = await tradesApi.getSignableTrade({
+            getSignableTradeRequest,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateTrade,
+            transactionData: getSignableTradeRequest,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const { payload_hash: payloadHash } = getSignableTradeResponse.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const { data: signableResultData } = getSignableTradeResponse;
+        const tradeParams = {
+            createTradeRequest: {
+                include_fees: true,
+                fees: request?.fees,
+                stark_signature: starkSignature,
+                order_id: request?.order_id,
+                fee_info: signableResultData.fee_info,
+                amount_buy: signableResultData.amount_buy,
+                amount_sell: signableResultData.amount_sell,
+                asset_id_buy: signableResultData.asset_id_buy,
+                asset_id_sell: signableResultData.asset_id_sell,
+                expiration_timestamp: signableResultData.expiration_timestamp,
+                nonce: signableResultData.nonce,
+                stark_key: signableResultData.stark_key,
+                vault_id_buy: signableResultData.vault_id_buy,
+                vault_id_sell: signableResultData.vault_id_sell,
+            },
+        };
+        const headers = { Authorization: 'Bearer ' + user.accessToken };
+        const { data: createTradeResponse } = await tradesApi.createTrade(tradeParams, {
+            headers,
+        });
+        return createTradeResponse;
+    }, PassportErrorType.CREATE_TRADE_ERROR);
+}
+
+class PassportImxProvider {
+    user;
+    starkSigner;
+    transfersApi;
+    ordersApi;
+    passportConfig;
+    exchangesApi;
+    tradesApi;
+    constructor({ user, starkSigner, passportConfig }) {
+        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);
+    }
+    async transfer(request) {
+        return transfer({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            transfersApi: this.transfersApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    registerOffchain() {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    isRegisteredOnchain() {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    createOrder(request) {
+        return createOrder({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            ordersApi: this.ordersApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    cancelOrder(request) {
+        return cancelOrder({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            ordersApi: this.ordersApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    createTrade(request) {
+        return createTrade({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            tradesApi: this.tradesApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    batchNftTransfer(request) {
+        return batchNftTransfer({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            transfersApi: this.transfersApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    exchangeTransfer(request) {
+        return exchangeTransfer({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            exchangesApi: this.exchangesApi,
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    deposit(deposit) {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    prepareWithdrawal(request) {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    completeWithdrawal(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    starkPublicKey, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    token) {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    getAddress() {
+        return Promise.resolve(this.starkSigner.getAddress());
+    }
+}
+
+var Networks;
+(function (Networks) {
+    Networks["PRODUCTION"] = "mainnet";
+    Networks["SANDBOX"] = "goerli";
+})(Networks || (Networks = {}));
+
+const validateConfiguration = (configuration, requiredKeys, prefix) => {
+    const missingKeys = requiredKeys
+        .map((key) => !configuration[key] && key)
+        .filter((n) => n)
+        .join(', ');
+    if (missingKeys !== '') {
+        const errorMessage = prefix
+            ? `${prefix} - ${missingKeys} cannot be null`
+            : `${missingKeys} cannot be null`;
+        throw new PassportError(errorMessage, PassportErrorType.INVALID_CONFIGURATION);
+    }
+};
+class PassportConfiguration {
+    network;
+    authenticationDomain;
+    passportDomain;
+    magicPublishableApiKey;
+    magicProviderId;
+    imxApiBasePath;
+    oidcConfiguration;
+    baseConfig;
+    constructor({ baseConfig, overrides, ...oidcConfiguration }) {
+        validateConfiguration(oidcConfiguration, [
+            'clientId',
+            'logoutRedirectUri',
+            'redirectUri',
+        ]);
+        this.oidcConfiguration = oidcConfiguration;
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            validateConfiguration(overrides, [
+                'network',
+                'authenticationDomain',
+                '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) {
+                case exports.Environment.SANDBOX: {
+                    this.network = Networks.SANDBOX;
+                    this.authenticationDomain = 'https://auth.immutable.com';
+                    this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
+                    this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
+                    this.passportDomain = 'https://passport.immutable.com';
+                    this.imxApiBasePath = 'https://api.x.immutable.com';
+                    break;
+                }
+                case exports.Environment.PRODUCTION: {
+                    this.network = Networks.PRODUCTION;
+                    this.authenticationDomain = 'https://auth.immutable.com';
+                    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;
+                }
+            }
+        }
+    }
+}
+
+const getStarkSigner = async (signer) => {
+    return withPassportError(async () => {
+        const privateKey = await coreSdk.generateLegacyStarkPrivateKey(signer);
+        return coreSdk.createStarkSigner(privateKey);
+    }, PassportErrorType.WALLET_CONNECTION_ERROR);
+};
+
+async function registerPassport({ ethSigner, starkSigner, usersApi }, authorization) {
+    return withPassportError(async () => {
+        const userAddress = await ethSigner.getAddress();
+        const starkPublicKey = await 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, ethSigner);
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const response = await usersApi.registerPassportUser({
+            authorization: `Bearer ` + authorization,
+            registerPassportUserRequest: {
+                eth_signature: ethSignature,
+                ether_key: userAddress,
+                stark_signature: starkSignature,
+                stark_key: starkPublicKey,
+            },
+        });
+        return response.statusText;
+    }, PassportErrorType.USER_REGISTRATION_ERROR);
+}
+
+class Passport {
+    authManager;
+    magicAdapter;
+    config;
+    constructor(passportModuleConfiguration) {
+        const passportConfiguration = new PassportConfiguration(passportModuleConfiguration);
+        this.config = passportConfiguration;
+        this.authManager = new AuthManager(this.config);
+        this.magicAdapter = new MagicAdapter(this.config);
+    }
+    async connectImx() {
+        const user = await this.authManager.login();
+        if (!user.idToken) {
+            throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
+        }
+        const provider = await this.magicAdapter.login(user.idToken);
+        const ethSigner = provider.getSigner();
+        const starkSigner = await getStarkSigner(ethSigner);
+        if (!user.etherKey) {
+            const updatedUser = await this.registerUser(ethSigner, starkSigner, user.accessToken);
+            return new PassportImxProvider({
+                user: updatedUser,
+                starkSigner,
+                passportConfig: this.config,
+            });
+        }
+        const userWithEtherKey = user;
+        return new PassportImxProvider({
+            user: userWithEtherKey,
+            starkSigner,
+            passportConfig: this.config,
+        });
+    }
+    async loginCallback() {
+        return this.authManager.loginCallback();
+    }
+    async logout() {
+        return this.authManager.logout();
+    }
+    async getUserInfo() {
+        const user = await this.authManager.getUser();
+        return user.profile;
+    }
+    async getIdToken() {
+        const user = await this.authManager.getUser();
+        return user.idToken;
+    }
+    async getAccessToken() {
+        const user = await this.authManager.getUser();
+        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,
+        }, jwt);
+        const updatedUser = await this.authManager.requestRefreshTokenAfterRegistration();
+        if (!updatedUser) {
+            throw new PassportError('Failed to get refresh token', PassportErrorType.REFRESH_TOKEN_ERROR);
+        }
+        return updatedUser;
+    }
+}
+
+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.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 = {}));
+
+
+
+
+let $a8bc256d81a5e2c1$export$e3dc0620abde7f5a;
+(function(CheckoutErrorType) {
+    CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
+    CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
+    CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_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["USER_REJECTED_REQUEST_ERROR"] = "USER_REJECTED_REQUEST_ERROR";
+    CheckoutErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
+})($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
+class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
+    constructor(message, type){
+        super(message);
+        this.type = type;
+    }
+}
+const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
+    try {
+        return await fn();
+    } catch (error) {
+        const errorMessage = customError.message || `${error.message}` || "UnknownError";
+        throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type);
+    }
+};
+
+
+
+
+
+
+
+async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider) {
+    const network = await provider.getNetwork();
+    if (!Object.values((exports.ChainId)).includes(network.chainId)) // return empty details
+    return {};
+    const chainIdNetworkInfo = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[network.chainId];
+    const networkInfo = {
+        name: chainIdNetworkInfo.chainName,
+        chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
+        nativeCurrency: chainIdNetworkInfo.nativeCurrency
+    };
+    return networkInfo;
+}
+async function $de192de6ef100f9f$export$b827d9418aeb5dbd(provider, chainId) {
+    if (!Object.values((exports.ChainId)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`${chainId} is not a supported chain`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR);
+    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("provider object is missing request function", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR);
+    // WT-1146 - Refer to the README in this folder for explantion on the switch network flow
+    try {
+        await $de192de6ef100f9f$var$switchNetworkInWallet(provider, chainId);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (err) {
+        if (err.message.includes("Unrecognized chain ID")) try {
+            await $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } catch (err) {
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("user cancelled the add network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
+        }
+        else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("user cancelled the switch network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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
+        }
+    };
+}
+// 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 = 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);
+        const balance = await provider.getBalance(walletAddress);
+        return {
+            balance: balance,
+            formattedBalance: (ethers.utils).formatUnits(balance, networkInfo.nativeCurrency.decimals),
+            token: networkInfo.nativeCurrency
+        };
+    }, {
+        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR);
+    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("provider object is missing request function", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR);
+    const tokenList = ($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
+    };
+};
+
+
+
+
+
+/* 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", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR);
+    const accounts = await provider.provider.request({
+        method: ($4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION,
+        params: []
+    });
+    // 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)("No MetaMask provider installed.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR);
+        // 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: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).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 was not detected", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CONNECT_PROVIDER_ERROR);
+    }
+    return web3Provider;
+}
+async function $c99672cf2294e839$var$getMetaMaskProvider() {
+    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        return await (detectEthereumProvider)();
+    }, {
+        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR
+    });
+    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR);
+    return new (providers.Web3Provider)(provider);
+}
+
+
+
+
+
+var $6f3c55a615003cbf$exports = {};
+$6f3c55a615003cbf$exports = JSON.parse('[{"connectionProvider":"metamask","icon":"some-icon-url","name":"MetaMask","description":"complete web3 wallet solution","platform":["mobile","desktop"]},{"connectionProvider":"passport","icon":"pp-icon","name":"Passport","description":"Web3 with your email!","platform":["mobile"]},{"connectionProvider":"gamestop","icon":"gme-icon","name":"GameStop","description":"Never stopping the game!","platform":["desktop"]}]');
+
+
+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 {
+        allowedWallets: 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: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).TRANSACTION_ERROR
+    });
+};
+
+
+
+
+class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
+    async checkIsWalletConnected(params) {
+        return $c99672cf2294e839$export$2d040992269b4717(params.providerPreference);
+    }
+    async connect(params) {
+        const provider = await $c99672cf2294e839$export$fba2f6c3656e07c1(params);
+        const network = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(provider);
+        return {
+            provider: provider,
+            network: network
+        };
+    }
+    async switchNetwork(params) {
+        return await ($de192de6ef100f9f$export$b827d9418aeb5dbd)(params.provider, params.chainId);
+    }
+    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);
+    }
+    async getAllBalances(params) {
+        return $1564e43dde50bb61$export$fee49741664a4d7e(params.provider, params.walletAddress, params.chainId);
+    }
+    getTokenAllowList(params) {
+        return $efe60cea83bfc4e8$export$473cec51305fdae8(params);
+    }
+    async getWalletsAllowList(params) {
+        return await $5cdde2ffe6360fec$export$a822caa90d7eef09(params);
+    }
+    async sendTransaction(params) {
+        return await $dbe95599a4661140$export$8e0e7ffc78696d30(params);
+    }
+}
+
+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";
+})(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 = {}));
+
+exports.Checkout = $a8cb37a3fc8eb863$export$1f60ba4ec72508a0;
+exports.GenericIMXProvider = GenericIMXProvider;
+exports.ImmutableConfiguration = ImmutableConfiguration;
+exports.MetaMaskIMXProvider = MetaMaskIMXProvider;
+exports.Passport = Passport;
+exports.PassportConfiguration = PassportConfiguration;
+exports.PassportError = PassportError;
+exports.ProviderConfiguration = ProviderConfiguration;
+exports.StarkExAPIFactory = StarkExAPIFactory;