@imtbl/sdk 0.0.1-alpha.3 → 0.1.1

package/dist/index.js

@@ -1,14 +1,11 @@
-import { ImmutableX, Config, TransfersApi, OrdersApi, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi, Configuration, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
-import BN from 'bn.js';
-import * as encUtils from 'enc-utils';
-import { parseUnits } from '@ethersproject/units';
-import { BigNumber } from '@ethersproject/bignumber';
-import { ethers, utils, Contract } from 'ethers';
-import detectEthereumProvider from '@metamask/detect-provider';
+import { ImmutableX, Config, Configuration, UsersApi, TransfersApi, OrdersApi, ExchangesApi, TradesApi, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
+export { createStarkSigner as imxClientCreateStarkSigner, generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey } from '@imtbl/core-sdk';
 import { UserManager } from 'oidc-client-ts';
+import { ethers } from 'ethers';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
-import { Web3Provider } from '@ethersproject/providers';
+import BN from 'bn.js';
+import * as encUtils from 'enc-utils';
 
 var Environment;
 (function (Environment) {
@@ -31,7 +28,7 @@ const PRODUCTION = () => {
         chainID: 1,
         coreContractAddress: '0x5FDCCA53617f4d2b9134B29090C87D01058e27e9',
         registrationContractAddress: '0x72a06bf2a1CE5e39cBA06c0CAb824960B587d64c',
-        sdkVersion: 'ts-immutable-sdk-0.0.1-alpha.3',
+        sdkVersion: 'ts-immutable-sdk-0.0.0',
     });
 };
 // Set `sdkVersion` on config
@@ -41,10 +38,10 @@ const SANDBOX = () => {
         chainID: 5,
         coreContractAddress: '0x7917eDb51ecD6CdB3F9854c3cc593F33de10c623',
         registrationContractAddress: '0x1C97Ada273C9A52253f463042f29117090Cd7D83',
-        sdkVersion: 'ts-immutable-sdk-0.0.1-alpha.3',
+        sdkVersion: 'ts-immutable-sdk-0.0.0',
     });
 };
-class StarkExConfiguration {
+class ImxConfiguration {
     immutableXConfig;
     baseConfig;
     constructor({ baseConfig, overrides }) {
@@ -67,11 +64,462 @@ class StarkExConfiguration {
     }
 }
 
-const StarkExAPIFactory = (config) => {
-    const imtblClient = new ImmutableX(config.immutableXConfig);
-    const { deposit, registerOffchain, isRegisteredOnchain, prepareWithdrawal, completeWithdrawal, createOrder, cancelOrder, createTrade, transfer, batchNftTransfer, ...StarkEx } = imtblClient;
-    return { ...StarkEx };
-};
+class ImmutableXClient {
+    immutableX;
+    depositsApi;
+    mintsApi;
+    ordersApi;
+    tokensApi;
+    tradesApi;
+    transfersApi;
+    exchangeApi;
+    nftCheckoutPrimaryApi;
+    usersApi;
+    withdrawalsApi;
+    balanceApi;
+    assetApi;
+    collectionApi;
+    metadataApi;
+    metadataRefreshesApi;
+    projectsApi;
+    constructor(config) {
+        const imxConfig = new ImxConfiguration(config);
+        this.immutableX = new ImmutableX(imxConfig.immutableXConfig);
+        this.depositsApi = this.immutableX.depositsApi;
+        this.mintsApi = this.immutableX.mintsApi;
+        this.ordersApi = this.immutableX.ordersApi;
+        this.tokensApi = this.immutableX.tokensApi;
+        this.tradesApi = this.immutableX.tradesApi;
+        this.transfersApi = this.immutableX.transfersApi;
+        this.exchangeApi = this.immutableX.exchangeApi;
+        this.usersApi = this.immutableX.usersApi;
+        this.withdrawalsApi = this.immutableX.withdrawalsApi;
+        this.balanceApi = this.immutableX.balanceApi;
+        this.assetApi = this.immutableX.assetApi;
+        this.collectionApi = this.immutableX.collectionApi;
+        this.metadataApi = this.immutableX.metadataApi;
+        this.metadataRefreshesApi = this.immutableX.metadataRefreshesApi;
+        this.nftCheckoutPrimaryApi = this.immutableX.nftCheckoutPrimaryApi;
+        this.projectsApi = this.immutableX.projectsApi;
+    }
+    /**
+     * Get details of a Deposit with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Deposit
+     * @throws {@link index.IMXError}
+     */
+    getDeposit(request) {
+        return this.immutableX.getDeposit(request);
+    }
+    /**
+     * Get a list of Deposits
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Deposits
+     * @throws {@link index.IMXError}
+     */
+    listDeposits(request) {
+        return this.immutableX.listDeposits(request);
+    }
+    /**
+     * Get Stark keys for a registered User
+     * @param ethAddress - the eth address of the User
+     * @returns a promise that resolves with the requested User
+     * @throws {@link index.IMXError}
+     */
+    getUser(ethAddress) {
+        return this.immutableX.getUser(ethAddress);
+    }
+    /**
+     * Get details of an Asset
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Asset
+     * @throws {@link index.IMXError}
+     */
+    getAsset(request) {
+        return this.immutableX.getAsset(request);
+    }
+    /**
+     * Get a list of Assets
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Assets
+     * @throws {@link index.IMXError}
+     */
+    listAssets(request) {
+        return this.immutableX.listAssets(request);
+    }
+    /**
+     * Create a Collection
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Collection
+     * @throws {@link index.IMXError}
+     */
+    createCollection(ethSigner, request) {
+        return this.immutableX.createCollection(ethSigner, request);
+    }
+    /**
+     * Get details of a Collection at the given address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Collection
+     * @throws {@link index.IMXError}
+     */
+    getCollection(request) {
+        return this.immutableX.getCollection(request);
+    }
+    /**
+     * Get a list of Collection filters
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collection Filters
+     * @throws {@link index.IMXError}
+     */
+    listCollectionFilters(request) {
+        return this.immutableX.listCollectionFilters(request);
+    }
+    /**
+     * Get a list of Collections
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collections
+     * @throws {@link index.IMXError}
+     */
+    listCollections(request) {
+        return this.collectionApi.listCollections(request).then((res) => res.data);
+    }
+    /**
+     * Update a Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the updated Collection
+     * @throws {@link index.IMXError}
+     */
+    updateCollection(ethSigner, collectionAddress, request) {
+        return this.immutableX.updateCollection(ethSigner, collectionAddress, request);
+    }
+    /**
+     * Add metadata schema to Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the SuccessResponse if successful
+     * @throws {@link index.IMXError}
+     */
+    addMetadataSchemaToCollection(ethSigner, collectionAddress, request) {
+        return this.immutableX.addMetadataSchemaToCollection(ethSigner, collectionAddress, request);
+    }
+    /**
+     * Get Metadata schema
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Metadata schema
+     * @throws {@link index.IMXError}
+     */
+    getMetadataSchema(request) {
+        return this.immutableX.getMetadataSchema(request);
+    }
+    /**
+     * Update metadata schema by name
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param name - the Metadata schema name
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the SuccessResponse if successful
+     * @throws {@link index.IMXError}
+     */
+    updateMetadataSchemaByName(ethSigner, collectionAddress, name, request) {
+        return this.immutableX.updateMetadataSchemaByName(ethSigner, collectionAddress, name, request);
+    }
+    /**
+     * Get a list of metadata refreshes
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refreshes
+     * @throws {@link index.IMXError}
+     */
+    listMetadataRefreshes(ethSigner, collectionAddress, pageSize, cursor) {
+        return this.immutableX.listMetadataRefreshes(ethSigner, collectionAddress, pageSize, cursor);
+    }
+    /**
+     * Get a list of metadata refresh errors
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refresh errors
+     * @throws {@link index.IMXError}
+     */
+    getMetadataRefreshErrors(ethSigner, refreshId, pageSize, cursor) {
+        return this.immutableX.getMetadataRefreshErrors(ethSigner, refreshId, pageSize, cursor);
+    }
+    /**
+     * Get a list of metadata refresh results
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @returns a promise that resolves with the requested metadata refresh results
+     * @throws {@link index.IMXError}
+     */
+    getMetadataRefreshResults(ethSigner, refreshId) {
+        return this.immutableX.getMetadataRefreshResults(ethSigner, refreshId);
+    }
+    /**
+     * Request a metadata refresh
+     * @param ethSigner - the L1 signer
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested metadata refresh
+     * @throws {@link index.IMXError}
+     */
+    createMetadataRefresh(ethSigner, request) {
+        return this.immutableX.createMetadataRefresh(ethSigner, request);
+    }
+    /**
+     * Create a Project
+     * @param ethSigner - the L1 signer
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the created Project
+     * @throws {@link index.IMXError}
+     */
+    async createProject(ethSigner, request) {
+        return this.immutableX.createProject(ethSigner, request);
+    }
+    /**
+     * Get a Project
+     * @param ethSigner - the L1 signer
+     * @param id - the Project ID
+     * @returns a promise that resolves with the requested Project
+     * @throws {@link index.IMXError}
+     */
+    async getProject(ethSigner, id) {
+        return this.immutableX.getProject(ethSigner, id);
+    }
+    /**
+     * Get Projects owned by the given User
+     * @param ethSigner - the L1 signer
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @param orderBy - the property to sort by
+     * @param direction - direction to sort (asc/desc)
+     * @returns a promise that resolves with the requested Projects
+     * @throws {@link index.IMXError}
+     */
+    async getProjects(ethSigner, pageSize, cursor, orderBy, direction) {
+        return this.immutableX.getProjects(ethSigner, pageSize, cursor, orderBy, direction);
+    }
+    /**
+     * Get the token Balances of the User
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Balance
+     * @throws {@link index.IMXError}
+     */
+    getBalance(request) {
+        return this.immutableX.getBalance(request);
+    }
+    /**
+     * Get a list of Balances for given User
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Balances
+     * @throws {@link index.IMXError}
+     */
+    listBalances(request) {
+        return this.immutableX.listBalances(request);
+    }
+    /**
+     * Get details of a Mint with the given ID
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Mint
+     * @throws {@link index.IMXError}
+     */
+    getMint(request) {
+        return this.immutableX.getMint(request);
+    }
+    /**
+     * Get a list of Mints
+     * @param request optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Mints
+     * @throws {@link index.IMXError}
+     */
+    listMints(request) {
+        return this.immutableX.listMints(request);
+    }
+    /**
+     * Mint tokens in a batch with fees
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the minted tokens
+     * @throws {@link index.IMXError}
+     */
+    mint(ethSigner, request) {
+        return this.immutableX.mint(ethSigner, request);
+    }
+    /**
+     * Get a list of Withdrawals
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Withdrawals
+     * @throws {@link index.IMXError}
+     */
+    listWithdrawals(request) {
+        return this.immutableX.listWithdrawals(request);
+    }
+    /**
+     * Get details of Withdrawal with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Withdrawal
+     * @throws {@link index.IMXError}
+     */
+    getWithdrawal(request) {
+        return this.immutableX.getWithdrawal(request);
+    }
+    /**
+     * Get details of an Order with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Order
+     * @throws {@link index.IMXError}
+     */
+    getOrder(request) {
+        return this.immutableX.getOrder(request);
+    }
+    /**
+     * Get a list of Orders
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Orders
+     * @throws {@link index.IMXError}
+     */
+    listOrders(request) {
+        return this.immutableX.listOrders(request);
+    }
+    /**
+     * Get details of a Trade with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Trade
+     * @throws {@link index.IMXError}
+     */
+    getTrade(request) {
+        return this.immutableX.getTrade(request);
+    }
+    /**
+     * Get a list of Trades
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Trades
+     * @throws {@link index.IMXError}
+     */
+    listTrades(request) {
+        return this.immutableX.listTrades(request);
+    }
+    /**
+     * Get details of a Token
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Token
+     * @throws {@link index.IMXError}
+     */
+    getToken(request) {
+        return this.immutableX.getToken(request);
+    }
+    /**
+     * Get a list of Tokens
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Tokens
+     * @throws {@link index.IMXError}
+     */
+    listTokens(request) {
+        return this.immutableX.listTokens(request);
+    }
+    /**
+     * Get details of a Transfer with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Transfer
+     * @throws {@link index.IMXError}
+     */
+    getTransfer(request) {
+        return this.immutableX.getTransfer(request);
+    }
+    /**
+     * Get a list of Transfers
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Transfers
+     * @throws {@link index.IMXError}
+     */
+    listTransfers(request) {
+        return this.immutableX.listTransfers(request);
+    }
+    /**
+     * Create a new Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transaction
+     * @throws {@link index.IMXError}
+     */
+    createExchange(request) {
+        return this.immutableX.createExchange(request).then((res) => res.data);
+    }
+    /**
+     * Get an Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the Exchange Transaction
+     * @throws {@link index.IMXError}
+     */
+    getExchange(request) {
+        return this.immutableX.getExchange(request).then((res) => res.data);
+    }
+    /**
+     * Get Exchange transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with Exchange Transactions
+     * @throws {@link index.IMXError}
+     */
+    getExchanges(request) {
+        return this.immutableX.getExchanges(request).then((res) => res.data);
+    }
+    /**
+     * Create a new Transfer request
+     * @param walletConnection - the pair of Eth/Stark signers
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transfer
+     * @throws {@link index.IMXError}
+     */
+    exchangeTransfer(walletConnection, request) {
+        return this.immutableX.exchangeTransfer(walletConnection, request);
+    }
+    /**
+     * Create a new nft primary transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created nft primary Transaction
+     * @throws {@link index.IMXError}
+     */
+    createNftPrimary(request) {
+        return this.immutableX.createNftPrimary(request).then((res) => res.data);
+    }
+    /**
+     * Get nft primary supported currencies and their limits
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary Currencies
+     * @throws {@link index.IMXError}
+     */
+    getCurrenciesNFTCheckoutPrimary(request) {
+        return this.immutableX
+            .getCurrenciesNFTCheckoutPrimary(request)
+            .then((res) => res.data);
+    }
+    /**
+     * Get nft primary transaction by transaction id
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link index.IMXError}
+     */
+    getNftPrimaryTransaction(request) {
+        return this.immutableX
+            .getNftPrimaryTransaction(request)
+            .then((res) => res.data);
+    }
+    /**
+     * Get list of nft primary transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link index.IMXError}
+     */
+    getNftPrimaryTransactions(request) {
+        return this.immutableX
+            .getNftPrimaryTransactions(request)
+            .then((res) => res.data);
+    }
+}
 
 // used to sign message with L1 keys. Used for registration
 function serializeEthSignature(sig) {
@@ -94,1106 +542,43 @@ function deserializeSignature(sig, size = 64) {
     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 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 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 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 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 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 = 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 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 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 UsersApi(starkExConfig.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = 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 = 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 = 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 UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = 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.sanitizeHex(encUtils.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 UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = 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 = 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 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 UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = 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 = 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 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 = parseUnits(deposit.amount, 'wei');
-    const starkExConfig = config.immutableXConfig;
-    const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
-    const usersApi = new 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 = 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 = 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 TokensApi(apiConfiguration);
-    const depositsApi = new DepositsApi(apiConfiguration);
-    const encodingApi = new EncodingApi(apiConfiguration);
-    const usersApi = new 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 = 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 = 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.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 = 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 = 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 DepositsApi(immutableXConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(immutableXConfig.apiConfiguration);
-    const usersApi = new 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 = 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 = 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 = 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 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.providers.Web3Provider(provider);
-}
-
-const COMMUNICATION_TYPE = 'message';
-var RequestEventType;
-(function (RequestEventType) {
-    RequestEventType["GET_CONNECTION_REQUEST"] = "GET_CONNECTION_REQUEST";
-    RequestEventType["CONNECT_WALLET_REQUEST"] = "CONNECT_WALLET_REQUEST";
-    RequestEventType["SIGN_MESSAGE_REQUEST"] = "SIGN_MESSAGE_REQUEST";
-    RequestEventType["DISCONNECT_WALLET_REQUEST"] = "DISCONNECT_WALLET_REQUEST";
-})(RequestEventType || (RequestEventType = {}));
-var ResponseEventType;
-(function (ResponseEventType) {
-    ResponseEventType["CONNECT_WALLET_RESPONSE"] = "CONNECT_WALLET_RESPONSE";
-    ResponseEventType["SIGN_MESSAGE_RESPONSE"] = "SIGN_MESSAGE_RESPONSE";
-    ResponseEventType["GET_CONNECTION_RESPONSE"] = "GET_CONNECTION_RESPONSE";
-    ResponseEventType["DISCONNECT_WALLET_RESPONSE"] = "DISCONNECT_WALLET_RESPONSE";
-})(ResponseEventType || (ResponseEventType = {}));
-
-function postRequestMessage(iframe, payload) {
-    if (iframe && iframe.contentWindow) {
-        iframe.contentWindow.postMessage(payload, new URL(iframe.src).origin);
-    }
-}
-
-function messageResponseListener(iframe, event, eventType, callback) {
-    if (iframe && event.source !== iframe.contentWindow) {
-        return;
-    }
-    const l2WalletMessage = event.data;
-    if (l2WalletMessage.type !== eventType) {
-        return;
-    }
-    callback(l2WalletMessage.details);
-}
-
-class ImxSigner {
-    publicAddress;
-    iframe;
-    constructor(publicAddress, iframe) {
-        this.publicAddress = publicAddress;
-        this.iframe = iframe;
-    }
-    getAddress() {
-        return this.publicAddress;
-    }
-    signMessage(rawMessage) {
-        return new Promise((resolve, reject) => {
-            const listener = (event) => {
-                messageResponseListener(this.iframe, event, ResponseEventType.SIGN_MESSAGE_RESPONSE, (messageDetails) => {
-                    window.removeEventListener(COMMUNICATION_TYPE, listener);
-                    if (!messageDetails.success) {
-                        reject(new Error(messageDetails.error?.message));
-                    }
-                    resolve(messageDetails.data.signedMessage);
-                });
-            };
-            window.addEventListener(COMMUNICATION_TYPE, listener);
-            postRequestMessage(this.iframe, {
-                type: RequestEventType.SIGN_MESSAGE_REQUEST,
-                details: { starkPublicKey: this.publicAddress, message: rawMessage },
-            });
-        });
-    }
-    getIFrame() {
-        return this.iframe;
-    }
-}
-
-const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
-const IMX_WALLET_IFRAME_HOSTS = {
-    [Environment.SANDBOX]: 'https://wallets.sandbox.immutable.com',
-    [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 });
-    }
+        recoveryParam: importRecoveryParam(sig.substring(size * 2, size * 2 + 2)),
+    };
+}
+async function signRaw(payload, signer) {
+    const signature = deserializeSignature(await signer.signMessage(payload));
+    return serializeEthSignature(signature);
 }
 
-class ProviderConfiguration {
-    immutableXConfig;
-    baseConfig;
-    constructor({ baseConfig, overrides }) {
-        this.baseConfig = baseConfig;
-        if (overrides) {
-            this.immutableXConfig = overrides.immutableXConfig;
-        }
-        else {
-            switch (baseConfig.environment) {
-                case Environment.SANDBOX: {
-                    this.immutableXConfig = Config.SANDBOX;
-                    break;
-                }
-                case Environment.PRODUCTION: {
-                    this.immutableXConfig = Config.PRODUCTION;
-                    break;
-                }
-            }
-        }
+/**
+ * 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,
+                },
+            };
     }
 }
 
@@ -1203,6 +588,7 @@ var PassportErrorType;
     PassportErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
     PassportErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
     PassportErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
+    PassportErrorType["SILENT_LOGIN_ERROR"] = "SILENT_LOGIN_ERROR";
     PassportErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
     PassportErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
     PassportErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
@@ -1284,6 +670,7 @@ class AuthManager {
     mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
         return {
+            expired: oidcUser.expired,
             idToken: oidcUser.id_token,
             accessToken: oidcUser.access_token,
             refreshToken: oidcUser.refresh_token,
@@ -1297,7 +684,7 @@ class AuthManager {
     };
     async login() {
         return withPassportError(async () => {
-            const popupWindowFeatures = { width: 400, height: 420 };
+            const popupWindowFeatures = { width: 410, height: 450 };
             const oidcUser = await this.userManager.signinPopup({
                 popupWindowFeatures,
             });
@@ -1310,11 +697,24 @@ class AuthManager {
     async logout() {
         return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
     }
+    async loginSilent() {
+        return withPassportError(async () => {
+            const existedUser = await this.getUser();
+            if (!existedUser) {
+                return null;
+            }
+            const oidcUser = await this.userManager.signinSilent();
+            if (!oidcUser) {
+                return null;
+            }
+            return this.mapOidcUserToDomainModel(oidcUser);
+        }, PassportErrorType.SILENT_LOGIN_ERROR);
+    }
     async getUser() {
         return withPassportError(async () => {
             const oidcUser = await this.userManager.getUser();
             if (!oidcUser) {
-                throw new Error('Failed to retrieve user');
+                return null;
             }
             return this.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
@@ -1972,9 +1372,8 @@ class Passport {
         this.authManager = new AuthManager(this.config);
         this.magicAdapter = new MagicAdapter(this.config);
     }
-    async connectImx() {
-        const user = await this.authManager.login();
-        if (!user.idToken) {
+    async getImxProvider(user) {
+        if (!user || !user.idToken) {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
         }
         const provider = await this.magicAdapter.login(user.idToken);
@@ -1995,6 +1394,17 @@ class Passport {
             passportConfig: this.config,
         });
     }
+    async connectImxSilent() {
+        const user = await this.authManager.loginSilent();
+        if (!user) {
+            return null;
+        }
+        return this.getImxProvider(user);
+    }
+    async connectImx() {
+        const user = await this.authManager.login();
+        return this.getImxProvider(user);
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
@@ -2003,15 +1413,15 @@ class Passport {
     }
     async getUserInfo() {
         const user = await this.authManager.getUser();
-        return user.profile;
+        return user?.profile;
     }
     async getIdToken() {
         const user = await this.authManager.getUser();
-        return user.idToken;
+        return user?.idToken;
     }
     async getAccessToken() {
         const user = await this.authManager.getUser();
-        return user.accessToken;
+        return user?.accessToken;
     }
     async registerUser(userAdminKeySigner, starkSigner, jwt) {
         const configuration = new Configuration({
@@ -2031,642 +1441,4 @@ class Passport {
     }
 }
 
-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"
-    }
-];
-
-
-let $d176a05e966364ba$export$3bfad4d03ada24c4;
-(function(ConnectionProviders) {
-    ConnectionProviders["METAMASK"] = "metamask";
-})($d176a05e966364ba$export$3bfad4d03ada24c4 || ($d176a05e966364ba$export$3bfad4d03ada24c4 = {}));
-
-
-let $a47e48dd2c04791b$export$c06e1e7429de6283;
-(function(ChainId) {
-    ChainId[ChainId["ETHEREUM"] = 1] = "ETHEREUM";
-    ChainId[ChainId["GOERLI"] = 5] = "GOERLI";
-    ChainId[ChainId["POLYGON"] = 137] = "POLYGON";
-})($a47e48dd2c04791b$export$c06e1e7429de6283 || ($a47e48dd2c04791b$export$c06e1e7429de6283 = {}));
-const $a47e48dd2c04791b$export$f61f4aaec62f6be9 = {
-    [$a47e48dd2c04791b$export$c06e1e7429de6283.ETHEREUM]: {
-        chainIdHex: "0x1",
-        chainName: "Ethereum",
-        rpcUrls: [
-            "https://mainnet.infura.io/v3/"
-        ],
-        nativeCurrency: {
-            name: "Ethereum",
-            symbol: "ETH",
-            decimals: 18
-        },
-        blockExplorerUrls: [
-            "https://etherscan.io/"
-        ]
-    },
-    [$a47e48dd2c04791b$export$c06e1e7429de6283.GOERLI]: {
-        chainIdHex: "0x5",
-        chainName: "Goerli",
-        rpcUrls: [
-            "https://goerli.infura.io/v3/"
-        ],
-        nativeCurrency: {
-            name: "Goerli Eth",
-            symbol: "ETH",
-            decimals: 18
-        },
-        blockExplorerUrls: [
-            "https://goerli.etherscan.io/"
-        ]
-    },
-    [$a47e48dd2c04791b$export$c06e1e7429de6283.POLYGON]: {
-        chainIdHex: "0x89",
-        chainName: "Polygon",
-        rpcUrls: [
-            "https://polygon-rpc.com"
-        ],
-        nativeCurrency: {
-            name: "MATIC",
-            symbol: "MATIC",
-            decimals: 18
-        },
-        blockExplorerUrls: [
-            "https://polygonscan.com/"
-        ]
-    }
-};
-let $a47e48dd2c04791b$export$1f05a55fe0680cc7;
-(function(NetworkFilterTypes) {
-    NetworkFilterTypes["ALL"] = "all";
-})($a47e48dd2c04791b$export$1f05a55fe0680cc7 || ($a47e48dd2c04791b$export$1f05a55fe0680cc7 = {}));
-
-
-let $08d5ddc39acd6833$export$fd9b17d87f4121d2;
-(function(TokenFilterTypes) {
-    TokenFilterTypes["SWAP"] = "swap";
-    TokenFilterTypes["BRIDGE"] = "bridge";
-    TokenFilterTypes["ALL"] = "all";
-})($08d5ddc39acd6833$export$fd9b17d87f4121d2 || ($08d5ddc39acd6833$export$fd9b17d87f4121d2 = {}));
-
-
-
-
-const $4f91c5f280efe242$export$a130407f3423b97d = {
-    CHECK_CONNECTION: "eth_accounts",
-    CONNECT: "eth_requestAccounts",
-    ADD_NETWORK: "wallet_addEthereumChain",
-    SWITCH_NETWORK: "wallet_switchEthereumChain"
-};
-let $4f91c5f280efe242$export$a75605c67ea83a5a;
-(function(WalletFilterTypes) {
-    WalletFilterTypes["ALL"] = "all";
-    WalletFilterTypes["DESKTOP"] = "desktop";
-    WalletFilterTypes["MOBILE"] = "mobile";
-})($4f91c5f280efe242$export$a75605c67ea83a5a || ($4f91c5f280efe242$export$a75605c67ea83a5a = {}));
-
-
-
-
-let $a8bc256d81a5e2c1$export$e3dc0620abde7f5a;
-(function(CheckoutErrorType) {
-    CheckoutErrorType["PROVIDER_PREFERENCE_ERROR"] = "PROVIDER_PREFERENCE_ERROR";
-    CheckoutErrorType["CONNECT_PROVIDER_ERROR"] = "CONNECT_PROVIDER_ERROR";
-    CheckoutErrorType["GET_BALANCE_ERROR"] = "GET_BALANCE_ERROR";
-    CheckoutErrorType["GET_ERC20_BALANCE_ERROR"] = "GET_ERC20_BALANCE_ERROR";
-    CheckoutErrorType["GET_NETWORK_INFO_ERROR"] = "GET_NETWORK_INFO_ERROR";
-    CheckoutErrorType["METAMASK_PROVIDER_ERROR"] = "METAMASK_PROVIDER_ERROR";
-    CheckoutErrorType["CHAIN_NOT_SUPPORTED_ERROR"] = "CHAIN_NOT_SUPPORTED_ERROR";
-    CheckoutErrorType["PROVIDER_REQUEST_MISSING_ERROR"] = "PROVIDER_REQUEST_MISSING_ERROR";
-    CheckoutErrorType["PROVIDER_REQUEST_FAILED_ERROR"] = "PROVIDER_REQUEST_FAILED_ERROR";
-    CheckoutErrorType["USER_REJECTED_REQUEST_ERROR"] = "USER_REJECTED_REQUEST_ERROR";
-    CheckoutErrorType["TRANSACTION_ERROR"] = "TRANSACTION_ERROR";
-})($a8bc256d81a5e2c1$export$e3dc0620abde7f5a || ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a = {}));
-class $a8bc256d81a5e2c1$export$b722478a3cbfa3bc extends Error {
-    constructor(message, type, data){
-        super(message);
-        this.message = message;
-        this.type = type;
-        this.data = data;
-    }
-}
-let $a8bc256d81a5e2c1$export$a22d4e0719ee6def;
-(function(CheckoutInternalErrorType) {
-    CheckoutInternalErrorType["REJECTED_SWITCH_AFTER_ADDING_NETWORK"] = "REJECTED_SWITCH_AFTER_ADDING_NETWORK";
-})($a8bc256d81a5e2c1$export$a22d4e0719ee6def || ($a8bc256d81a5e2c1$export$a22d4e0719ee6def = {}));
-class $a8bc256d81a5e2c1$export$620a0d5f1b58ea1d extends Error {
-    constructor(type){
-        super("Checkout internal error");
-        this.type = type;
-    }
-}
-const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
-    try {
-        return await fn();
-    } catch (error) {
-        const cause = `${error.message}` || "UnknownError";
-        const errorMessage = customError.message ? `[${customError.type}]:${customError.message}. Cause:${cause}` : `[${customError.type}] Cause:${cause}`;
-        if (error instanceof $a8bc256d81a5e2c1$export$b722478a3cbfa3bc) throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
-            ...customError.data,
-            innerErrorType: error.type,
-            ...error.data
-        });
-        throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
-            ...customError.data
-        });
-    }
-};
-
-
-
-
-/* eslint-disable @typescript-eslint/no-explicit-any */ 
-
-var $497c134ecbc8a50f$exports = {};
-$497c134ecbc8a50f$exports = JSON.parse('[{"chainId":1},{"chainId":5},{"chainId":137}]');
-
-
-const $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE = 4902; // error code (MetaMask)
-async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider) {
-    return ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const network = await provider.getNetwork();
-        if (!Object.values(($a47e48dd2c04791b$export$c06e1e7429de6283)).includes(network.chainId)) // return empty details
-        return {
-            chainId: network.chainId,
-            name: network.name,
-            isSupported: false
-        };
-        const chainIdNetworkInfo = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[network.chainId];
-        return {
-            name: chainIdNetworkInfo.chainName,
-            chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
-            nativeCurrency: chainIdNetworkInfo.nativeCurrency,
-            isSupported: true
-        };
-    }, {
-        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_NETWORK_INFO_ERROR
-    });
-}
-async function $de192de6ef100f9f$export$b827d9418aeb5dbd(provider, chainId) {
-    if (!Object.values(($a47e48dd2c04791b$export$c06e1e7429de6283)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${chainId} is not a supported chain`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR);
-    if (!provider || !provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR, {
-        details: `Unsupported provider`
-    });
-    // WT-1146 - Refer to the README in this folder for explantion on the switch network flow
-    try {
-        await $de192de6ef100f9f$var$switchNetworkInWallet(provider, chainId);
-    } catch (err) {
-        if (err.code === $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE) try {
-            await $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId);
-            if ((await provider.getNetwork()).chainId !== chainId) // user didn't actually switch
-            throw new (0, $a8bc256d81a5e2c1$export$620a0d5f1b58ea1d)((0, $a8bc256d81a5e2c1$export$a22d4e0719ee6def).REJECTED_SWITCH_AFTER_ADDING_NETWORK);
-        } catch (err) {
-            if (err?.type === ($a8bc256d81a5e2c1$export$a22d4e0719ee6def).REJECTED_SWITCH_AFTER_ADDING_NETWORK) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled add network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
-        }
-        else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled 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
-        }
-    };
-}
-async function $de192de6ef100f9f$export$3043f6442a9ef563({ type: type = ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL , exclude: exclude  }) {
-    const list = ((/*@__PURE__*/$parcel$interopDefault($497c134ecbc8a50f$exports))).filter((network)=>{
-        const allowAllTokens = type === ($a47e48dd2c04791b$export$1f05a55fe0680cc7).ALL;
-        const networkNotExcluded = !(exclude || []).map((exc)=>exc.chainId).includes(network.chainId);
-        return allowAllTokens && networkNotExcluded;
-    });
-    const allowedNetworks = [];
-    list.forEach((element)=>{
-        const newNetwork = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[element.chainId];
-        allowedNetworks.push({
-            name: newNetwork.chainName,
-            chainId: parseInt(newNetwork.chainIdHex, 16),
-            nativeCurrency: newNetwork.nativeCurrency,
-            isSupported: true
-        });
-    });
-    return {
-        networks: allowedNetworks
-    };
-}
-// these functions should not be exported. These functions should be used as part of an exported function e.g switchWalletNetwork() above.
-// make sure to check if(provider.provider?.request) in the exported function and throw an error
-async function $de192de6ef100f9f$var$switchNetworkInWallet(provider, chainId) {
-    if (provider.provider?.request) return await provider.provider.request({
-        method: ($4f91c5f280efe242$export$a130407f3423b97d).SWITCH_NETWORK,
-        params: [
-            {
-                chainId: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainIdHex
-            }
-        ]
-    });
-}
-async function $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId) {
-    if (provider.provider?.request) {
-        const addNetwork = {
-            chainId: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainIdHex,
-            chainName: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].chainName,
-            rpcUrls: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].rpcUrls,
-            nativeCurrency: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].nativeCurrency,
-            blockExplorerUrls: ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[chainId].blockExplorerUrls
-        };
-        return await provider.provider.request({
-            method: ($4f91c5f280efe242$export$a130407f3423b97d).ADD_NETWORK,
-            params: [
-                addNetwork
-            ]
-        });
-    }
-}
-
-
-
-
-
-var $cda6003506e4182e$exports = {};
-$cda6003506e4182e$exports = JSON.parse("[{\"address\":\"0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0\",\"chainId\":137,\"name\":\"Matic\",\"symbol\":\"MATIC\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 38.4 33.5' style='enable-background:new 0 0 38.4 33.5;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bfill:%238247E5;%7D%0A%3C/style%3E%3Cg%3E%3Cpath class='st0' d='M29,10.2c-0.7-0.4-1.6-0.4-2.4,0L21,13.5l-3.8,2.1l-5.5,3.3c-0.7,0.4-1.6,0.4-2.4,0L5,16.3 c-0.7-0.4-1.2-1.2-1.2-2.1v-5c0-0.8,0.4-1.6,1.2-2.1l4.3-2.5c0.7-0.4,1.6-0.4,2.4,0L16,7.2c0.7,0.4,1.2,1.2,1.2,2.1v3.3l3.8-2.2V7 c0-0.8-0.4-1.6-1.2-2.1l-8-4.7c-0.7-0.4-1.6-0.4-2.4,0L1.2,5C0.4,5.4,0,6.2,0,7v9.4c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l5.5-3.2l3.8-2.2l5.5-3.2c0.7-0.4,1.6-0.4,2.4,0l4.3,2.5c0.7,0.4,1.2,1.2,1.2,2.1v5c0,0.8-0.4,1.6-1.2,2.1 L29,28.8c-0.7,0.4-1.6,0.4-2.4,0l-4.3-2.5c-0.7-0.4-1.2-1.2-1.2-2.1V21l-3.8,2.2v3.3c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l8.1-4.7c0.7-0.4,1.2-1.2,1.2-2.1V17c0-0.8-0.4-1.6-1.2-2.1L29,10.2z'/%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"name\":\"Ethereum\",\"symbol\":\"ETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"chainId\":1,\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF\",\"chainId\":1,\"name\":\"Immutable X\",\"symbol\":\"IMX\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0\",\"chainId\":1,\"name\":\"Matic\",\"symbol\":\"MATIC\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 38.4 33.5' style='enable-background:new 0 0 38.4 33.5;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bfill:%238247E5;%7D%0A%3C/style%3E%3Cg%3E%3Cpath class='st0' d='M29,10.2c-0.7-0.4-1.6-0.4-2.4,0L21,13.5l-3.8,2.1l-5.5,3.3c-0.7,0.4-1.6,0.4-2.4,0L5,16.3 c-0.7-0.4-1.2-1.2-1.2-2.1v-5c0-0.8,0.4-1.6,1.2-2.1l4.3-2.5c0.7-0.4,1.6-0.4,2.4,0L16,7.2c0.7,0.4,1.2,1.2,1.2,2.1v3.3l3.8-2.2V7 c0-0.8-0.4-1.6-1.2-2.1l-8-4.7c-0.7-0.4-1.6-0.4-2.4,0L1.2,5C0.4,5.4,0,6.2,0,7v9.4c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l5.5-3.2l3.8-2.2l5.5-3.2c0.7-0.4,1.6-0.4,2.4,0l4.3,2.5c0.7,0.4,1.2,1.2,1.2,2.1v5c0,0.8-0.4,1.6-1.2,2.1 L29,28.8c-0.7,0.4-1.6,0.4-2.4,0l-4.3-2.5c-0.7-0.4-1.2-1.2-1.2-2.1V21l-3.8,2.2v3.3c0,0.8,0.4,1.6,1.2,2.1l8.1,4.7 c0.7,0.4,1.6,0.4,2.4,0l8.1-4.7c0.7-0.4,1.2-1.2,1.2-2.1V17c0-0.8-0.4-1.6-1.2-2.1L29,10.2z'/%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"name\":\"Ethereum\",\"symbol\":\"ETH\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='UTF-8'%3F%3E%3C!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN' 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'%3E%3Csvg xmlns='http://www.w3.org/2000/svg' xml:space='preserve' width='100%25' height='100%25' version='1.1' shape-rendering='geometricPrecision' text-rendering='geometricPrecision' image-rendering='optimizeQuality' fill-rule='evenodd' clip-rule='evenodd'%0AviewBox='0 0 784.37 1277.39' xmlns:xlink='http://www.w3.org/1999/xlink' xmlns:xodm='http://www.corel.com/coreldraw/odm/2003'%3E%3Cg id='Layer_x0020_1'%3E%3Cmetadata id='CorelCorpID_0Corel-Layer'/%3E%3Cg id='_1421394342400'%3E%3Cg%3E%3Cpolygon fill='%23343434' fill-rule='nonzero' points='392.07,0 383.5,29.11 383.5,873.74 392.07,882.29 784.13,650.54 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,0 -0,650.54 392.07,882.29 392.07,472.33 '/%3E%3Cpolygon fill='%233C3C3B' fill-rule='nonzero' points='392.07,956.52 387.24,962.41 387.24,1263.28 392.07,1277.38 784.37,724.89 '/%3E%3Cpolygon fill='%238C8C8C' fill-rule='nonzero' points='392.07,1277.38 392.07,956.52 -0,724.89 '/%3E%3Cpolygon fill='%23141414' fill-rule='nonzero' points='392.07,882.29 784.13,650.54 392.07,472.33 '/%3E%3Cpolygon fill='%23393939' fill-rule='nonzero' points='0,650.54 392.07,882.29 392.07,472.33 '/%3E%3C/g%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"chainId\":5,\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x1facdd0165489f373255a90304650e15481b2c85\",\"chainId\":5,\"name\":\"Immutable X\",\"symbol\":\"IMX\",\"decimals\":18,\"icon\":\"data:image/svg+xml,%3C%3Fxml version='1.0' encoding='utf-8'%3F%3E%3Csvg version='1.1' id='Layer_1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' x='0px' y='0px' viewBox='0 0 139 113' style='enable-background:new 0 0 139 113;' xml:space='preserve'%3E%3Cstyle type='text/css'%3E .st0%7Bclip-path:url(%23SVGID_00000053504646934646330740000009134454895836103350_);%7D .st1%7Bfill:%2317B5CB;%7D%0A%3C/style%3E%3Cg%3E%3Cdefs%3E%3Crect id='SVGID_1_' width='139' height='113'/%3E%3C/defs%3E%3CclipPath id='SVGID_00000035518931339590433170000002358037249938198420_'%3E%3Cuse xlink:href='%23SVGID_1_' style='overflow:visible;'/%3E%3C/clipPath%3E%3Cg style='clip-path:url(%23SVGID_00000035518931339590433170000002358037249938198420_);'%3E%3Cpath class='st1' d='M124.1,0h14.6L79.5,67.6c-1.5,1.7-1.6,4.3-0.1,6.1l34.1,39.7H98.3L66.8,76.6l-1.6-2c-1.5-1.7-1.4-4.4,0.1-6.1 L124.1,0z'/%3E%3Cpath class='st1' d='M91.2,73.7c-1-1.1-1.3-2.7-1-4.1c0.3-0.8,0.8-1.6,1.4-2.2l3.9-4.3l43.5,50.3h-13.8 C125.2,113.4,99.7,83.6,91.2,73.7z'/%3E%3Cpath class='st1' d='M15.2,113.4H0l46.6-53.9c1.5-1.7,1.5-4.3,0-6L0.4,0H15l46.5,53.9c1.2,1.6,1.4,3.9,0.1,5.4 C49.4,73.4,15.2,113.4,15.2,113.4z'/%3E%3Cpath class='st1' d='M40.6,0h-14l43.1,49.9c0,0,0.1-0.1,4.9-5.8c1.3-1.5,1.6-3.4,0.1-4.9C65.7,30,40.6,0,40.6,0z'/%3E%3Cpath class='st1' d='M82.6,34.8L112.5,0H98.3L82.7,18.2l-4.5,5.3c-1.5,1.7-1.6,4.3-0.1,6.1C79.2,30.9,82.6,34.8,82.6,34.8z'/%3E%3Cpath class='st1' d='M56.6,78.6l-29.9,34.8h14.1l15.6-18.2l4.5-5.3c1.5-1.7,1.6-4.3,0.1-6.1C59.9,82.5,56.6,78.6,56.6,78.6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E%0A\",\"tokenFeatures\":[\"swap\",\"bridge\"]},{\"address\":\"0x123456789\",\"chainId\":5,\"name\":\"Swap Coin\",\"symbol\":\"SWC\",\"decimals\":18,\"tokenFeatures\":[\"swap\",\"fakeFeature\"]},{\"address\":\"0x123456789\",\"chainId\":5,\"name\":\"Bridge Coin\",\"symbol\":\"BDC\",\"decimals\":18,\"tokenFeatures\":[\"bridge\",\"fakeFeature\"]}]");
-
-
-const $efe60cea83bfc4e8$export$473cec51305fdae8 = async function({ type: type = ($08d5ddc39acd6833$export$fd9b17d87f4121d2).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 === ($08d5ddc39acd6833$export$fd9b17d87f4121d2).ALL;
-        const tokenAllowedForType = token.tokenFeatures.includes(type);
-        return chainIdMatches && tokenNotExcluded && (allowAllTokens || tokenAllowedForType);
-    }).map((token)=>{
-        const { chainId: chainId , tokenFeatures: tokenFeatures , ...tokenInfo } = token;
-        return tokenInfo;
-    });
-    return {
-        tokens: filteredTokenList
-    };
-};
-
-
-
-
-const $1564e43dde50bb61$export$df96cd8d56be0ab1 = async (provider, walletAddress)=>{
-    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const networkInfo = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(provider);
-        if (!networkInfo.isSupported) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Chain:${networkInfo.chainId} is not a supported chain`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR, {
-            chainName: networkInfo.name
-        });
-        const balance = await provider.getBalance(walletAddress);
-        return {
-            balance: balance,
-            formattedBalance: (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 (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 = (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(($a47e48dd2c04791b$export$c06e1e7429de6283)).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 = await ($efe60cea83bfc4e8$export$473cec51305fdae8)({
-        type: ($08d5ddc39acd6833$export$fd9b17d87f4121d2).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, {
-        details: `Unsupported provider for ${providerPreference}`
-    });
-    let accounts = [];
-    try {
-        accounts = await provider.provider.request({
-            method: (0, $4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION,
-            params: []
-        });
-    } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Check wallet connection request failed`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_FAILED_ERROR, {
-            rpcMethod: ($4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION
-        });
-    }
-    // accounts[0] will have the active account if connected.
-    return {
-        isConnected: accounts && accounts.length > 0,
-        walletAddress: accounts[0] ?? ""
-    };
-}
-async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
-    const web3Provider = await $c99672cf2294e839$var$getWalletProviderForPreference(params.providerPreference);
-    await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        if (!web3Provider || !web3Provider?.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR, {
-            details: `Unsupported provider for ${params.providerPreference}`
-        });
-        // this makes the request to the wallet to connect i.e request eth accounts ('eth_requestAccounts')
-        await web3Provider.provider.request({
-            method: ($4f91c5f280efe242$export$a130407f3423b97d).CONNECT,
-            params: []
-        });
-    }, {
-        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR
-    });
-    return web3Provider;
-}
-async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
-    let web3Provider = null;
-    switch(providerPreference){
-        case ($d176a05e966364ba$export$3bfad4d03ada24c4).METAMASK:
-            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
-            break;
-        default:
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_PREFERENCE_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 (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 = ($4f91c5f280efe242$export$a75605c67ea83a5a).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 === ($4f91c5f280efe242$export$a75605c67ea83a5a).ALL;
-        const walletsAllowedForType = wallet.platform.includes(type);
-        return walletNotExcluded && (allowAllWallets || walletsAllowedForType);
-    }).map((wallet)=>{
-        const { platform: platform , ...walletInfo } = wallet;
-        return walletInfo;
-    });
-    return {
-        wallets: filteredWalletsList
-    };
-}
-
-
-
-
-
-
-const $dbe95599a4661140$export$8e0e7ffc78696d30 = async (params)=>{
-    const { provider: provider , transaction: transaction  } = params;
-    return await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        const transactionResponse = await provider.getSigner().sendTransaction(transaction);
-        return {
-            transactionResponse: transactionResponse
-        };
-    }, {
-        type: ($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 networkInfo = await $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider);
-        return {
-            provider: provider,
-            network: networkInfo
-        };
-    }
-    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);
-    }
-    async getNetworkAllowList(params) {
-        return await $de192de6ef100f9f$export$3043f6442a9ef563(params);
-    }
-    async getTokenAllowList(params) {
-        return await $efe60cea83bfc4e8$export$473cec51305fdae8(params);
-    }
-    async getWalletsAllowList(params) {
-        return await $5cdde2ffe6360fec$export$a822caa90d7eef09(params);
-    }
-    async sendTransaction(params) {
-        return await $dbe95599a4661140$export$8e0e7ffc78696d30(params);
-    }
-    async getNetworkInfo(params) {
-        return await $de192de6ef100f9f$export$79f13b4cfaaf0d09(params.provider);
-    }
-}
-
-function $parcel$export(e, n, v, s) {
-  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
-}
-var $88e4c575901cd68c$exports = {};
-
-$parcel$export($88e4c575901cd68c$exports, "IMTBLWidgetEvents", () => $88e4c575901cd68c$export$5a0ace85cae72d45);
-let $88e4c575901cd68c$export$5a0ace85cae72d45;
-(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";
-})($88e4c575901cd68c$export$5a0ace85cae72d45 || ($88e4c575901cd68c$export$5a0ace85cae72d45 = {}));
-
-
-var $d71a87afc3136184$exports = {};
-
-$parcel$export($d71a87afc3136184$exports, "ConnectEventType", () => $d71a87afc3136184$export$e72e7f9969a47dd3);
-let $d71a87afc3136184$export$e72e7f9969a47dd3;
-(function(ConnectEventType) {
-    ConnectEventType["SUCCESS"] = "success";
-    ConnectEventType["FAILURE"] = "failure";
-    ConnectEventType["CLOSE_WIDGET"] = "close-widget";
-})($d71a87afc3136184$export$e72e7f9969a47dd3 || ($d71a87afc3136184$export$e72e7f9969a47dd3 = {}));
-
-
-var $9d0f1783d4d36e8a$exports = {};
-
-$parcel$export($9d0f1783d4d36e8a$exports, "WalletEventType", () => $9d0f1783d4d36e8a$export$d9be06b70b28c742);
-//wallet widget events
-let $9d0f1783d4d36e8a$export$d9be06b70b28c742;
-(function(WalletEventType) {
-    WalletEventType["CLOSE_WIDGET"] = "close-widget";
-    WalletEventType["NETWORK_SWITCH"] = "network-switch";
-})($9d0f1783d4d36e8a$export$d9be06b70b28c742 || ($9d0f1783d4d36e8a$export$d9be06b70b28c742 = {}));
-
-
-var $5d497088f13bb116$exports = {};
-
-$parcel$export($5d497088f13bb116$exports, "SwapEventType", () => $5d497088f13bb116$export$140a49745ab55563);
-let $5d497088f13bb116$export$140a49745ab55563;
-(function(SwapEventType) {
-    SwapEventType["SUCCESS"] = "success";
-    SwapEventType["FAILURE"] = "failure";
-})($5d497088f13bb116$export$140a49745ab55563 || ($5d497088f13bb116$export$140a49745ab55563 = {}));
-
-
-var $28a5fdc2f5e6c742$exports = {};
-
-$parcel$export($28a5fdc2f5e6c742$exports, "BridgeEventType", () => $28a5fdc2f5e6c742$export$d1bfa21f7c76447a);
-let $28a5fdc2f5e6c742$export$d1bfa21f7c76447a;
-(function(BridgeEventType) {
-    BridgeEventType["CLOSE_WIDGET"] = "close-widget";
-    BridgeEventType["SUCCESS"] = "success";
-    BridgeEventType["FAILURE"] = "failure";
-})($28a5fdc2f5e6c742$export$d1bfa21f7c76447a || ($28a5fdc2f5e6c742$export$d1bfa21f7c76447a = {}));
-
-
-var $ede253beebe0de4a$exports = {};
-
-$parcel$export($ede253beebe0de4a$exports, "BuyEventType", () => $ede253beebe0de4a$export$90db5fe1be5993c1);
-let $ede253beebe0de4a$export$90db5fe1be5993c1;
-(function(BuyEventType) {
-    BuyEventType["SUCCESS"] = "success";
-    BuyEventType["FAILURE"] = "failure";
-    BuyEventType["NOT_CONNECTED"] = "not_connected";
-    BuyEventType["CLOSE"] = "close";
-})($ede253beebe0de4a$export$90db5fe1be5993c1 || ($ede253beebe0de4a$export$90db5fe1be5993c1 = {}));
-
-
-var $9234b4c577442a97$exports = {};
-
-$parcel$export($9234b4c577442a97$exports, "Network", () => $9234b4c577442a97$export$95be4ae94445245a);
-$parcel$export($9234b4c577442a97$exports, "WidgetTheme", () => $9234b4c577442a97$export$c88931fdc51854eb);
-$parcel$export($9234b4c577442a97$exports, "ConnectionProviders", () => $d176a05e966364ba$export$3bfad4d03ada24c4);
-
-let $9234b4c577442a97$export$95be4ae94445245a;
-(function(Network) {
-    Network["ETHEREUM"] = "Ethereum";
-    Network["GOERLI"] = "Goerli";
-    Network["POLYGON"] = "Polygon";
-})($9234b4c577442a97$export$95be4ae94445245a || ($9234b4c577442a97$export$95be4ae94445245a = {}));
-let $9234b4c577442a97$export$c88931fdc51854eb;
-(function(WidgetTheme) {
-    WidgetTheme["LIGHT"] = "light";
-    WidgetTheme["DARK"] = "dark";
-    WidgetTheme["CUSTOM"] = "custom";
-})($9234b4c577442a97$export$c88931fdc51854eb || ($9234b4c577442a97$export$c88931fdc51854eb = {}));
-
-export { $28a5fdc2f5e6c742$export$d1bfa21f7c76447a as BridgeEventType, $ede253beebe0de4a$export$90db5fe1be5993c1 as BuyEventType, $a47e48dd2c04791b$export$c06e1e7429de6283 as ChainId, $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 as Checkout, $d71a87afc3136184$export$e72e7f9969a47dd3 as ConnectEventType, $d176a05e966364ba$export$3bfad4d03ada24c4 as ConnectionProviders, Environment, GenericIMXProvider, $88e4c575901cd68c$export$5a0ace85cae72d45 as IMTBLWidgetEvents, ImmutableConfiguration, MetaMaskIMXProvider, $9234b4c577442a97$export$95be4ae94445245a as Network, $a47e48dd2c04791b$export$1f05a55fe0680cc7 as NetworkFilterTypes, Passport, PassportConfiguration, PassportError, ProviderConfiguration, StarkExAPIFactory, StarkExConfiguration, $5d497088f13bb116$export$140a49745ab55563 as SwapEventType, $08d5ddc39acd6833$export$fd9b17d87f4121d2 as TokenFilterTypes, $9d0f1783d4d36e8a$export$d9be06b70b28c742 as WalletEventType, $4f91c5f280efe242$export$a75605c67ea83a5a as WalletFilterTypes, $9234b4c577442a97$export$c88931fdc51854eb as WidgetTheme };
+export { Environment, ImmutableConfiguration, ImmutableXClient, Passport, PassportError };