@imtbl/sdk 0.0.1-alpha.2 → 0.1.0-alpha

package/dist/index.js

@@ -1,45 +1,529 @@
-import { Config as Config$1, ImmutableX, TransfersApi, OrdersApi, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi, Configuration as Configuration$1, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
+import { ImmutableX, Config, Configuration, UsersApi, TransfersApi, OrdersApi, ExchangesApi, TradesApi, generateLegacyStarkPrivateKey, createStarkSigner, Contracts, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi } from '@imtbl/core-sdk';
+export { createStarkSigner as imxClientCreateStarkSigner, generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey } from '@imtbl/core-sdk';
+import { UserManager } from 'oidc-client-ts';
+import { ethers, utils, Contract } from 'ethers';
+import { Magic } from 'magic-sdk';
+import { OpenIdExtension } from '@magic-ext/oidc';
 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 { UserManager } from 'oidc-client-ts';
-import { Magic } from 'magic-sdk';
-import { OpenIdExtension } from '@magic-ext/oidc';
 import { Web3Provider } from '@ethersproject/providers';
 
 var Environment;
 (function (Environment) {
-    Environment["DEVELOPMENT"] = "development";
-    Environment["SANDBOX"] = "sandbox";
     Environment["PRODUCTION"] = "production";
+    Environment["SANDBOX"] = "sandbox";
 })(Environment || (Environment = {}));
-class Configuration {
-    starkExConfig;
-    constructor(config) {
-        this.starkExConfig = config;
-    }
-    getStarkExConfig() {
-        return this.starkExConfig;
-    }
-}
-const PRODUCTION = {
-    ...Config$1.PRODUCTION,
-    env: Environment.PRODUCTION,
+class ImmutableConfiguration {
+    environment;
+    apiKey;
+    constructor(options) {
+        this.environment = options.environment;
+        this.apiKey = options.apiKey;
+    }
+}
+
+// Set `sdkVersion` on config
+const PRODUCTION = () => {
+    return Config.createConfig({
+        basePath: 'https://api.x.immutable.com',
+        chainID: 1,
+        coreContractAddress: '0x5FDCCA53617f4d2b9134B29090C87D01058e27e9',
+        registrationContractAddress: '0x72a06bf2a1CE5e39cBA06c0CAb824960B587d64c',
+        sdkVersion: 'ts-immutable-sdk-0.1.0-alpha',
+    });
 };
-const SANDBOX = {
-    ...Config$1.SANDBOX,
-    env: Environment.SANDBOX,
+// Set `sdkVersion` on config
+const SANDBOX = () => {
+    return Config.createConfig({
+        basePath: 'https://api.sandbox.x.immutable.com',
+        chainID: 5,
+        coreContractAddress: '0x7917eDb51ecD6CdB3F9854c3cc593F33de10c623',
+        registrationContractAddress: '0x1C97Ada273C9A52253f463042f29117090Cd7D83',
+        sdkVersion: 'ts-immutable-sdk-0.1.0-alpha',
+    });
 };
+class ImxConfiguration {
+    immutableXConfig;
+    baseConfig;
+    constructor({ baseConfig, overrides }) {
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            this.immutableXConfig = overrides.immutableXConfig;
+        }
+        else {
+            switch (baseConfig.environment) {
+                case Environment.SANDBOX: {
+                    this.immutableXConfig = SANDBOX();
+                    break;
+                }
+                case Environment.PRODUCTION: {
+                    this.immutableXConfig = PRODUCTION();
+                    break;
+                }
+            }
+        }
+    }
+}
 
-/* eslint-disable @typescript-eslint/no-unused-vars */
-const StarkExAPIFactory = (config) => {
-    const imtblClient = new ImmutableX(config.getStarkExConfig());
-    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) {
@@ -111,1876 +595,1923 @@ function convertToSignableToken(token) {
     }
 }
 
-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.');
+var PassportErrorType;
+(function (PassportErrorType) {
+    PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+    PassportErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
+    PassportErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
+    PassportErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
+    PassportErrorType["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";
+    PassportErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
+    PassportErrorType["CREATE_ORDER_ERROR"] = "CREATE_ORDER_ERROR";
+    PassportErrorType["CANCEL_ORDER_ERROR"] = "CANCEL_ORDER_ERROR";
+    PassportErrorType["EXCHANGE_TRANSFER_ERROR"] = "EXCHANGE_TRANSFER_ERROR";
+    PassportErrorType["CREATE_TRADE_ERROR"] = "CREATE_TRADE_ERROR";
+    PassportErrorType["OPERATION_NOT_SUPPORTED_ERROR"] = "OPERATION_NOT_SUPPORTED_ERROR";
+})(PassportErrorType || (PassportErrorType = {}));
+class PassportError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
+    }
 }
+const withPassportError = async (fn, customErrorType) => {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        const errorMessage = `${customErrorType}: ${error.message}` || 'UnknownError';
+        throw new PassportError(errorMessage, customErrorType);
+    }
+};
 
-async function transfer$1({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi(config.getStarkExConfig().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 POLL_INTERVAL = 1 * 1000; // every 1 second
+const MAX_RETRIES = 3;
+const wait = (ms) => new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+});
+const retryWithDelay = async (fn, options) => {
+    const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), } = options || {};
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (retries <= 0) {
+            return Promise.reject(finalErr);
+        }
+        await wait(interval);
+        return retryWithDelay(fn, { retries: retries - 1, finalErr });
+    }
+};
+
+const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
+    const baseConfiguration = {
+        authority: authenticationDomain,
+        redirect_uri: oidcConfiguration.redirectUri,
+        popup_redirect_uri: oidcConfiguration.redirectUri,
+        client_id: oidcConfiguration.clientId,
+        metadata: {
+            authorization_endpoint: `${authenticationDomain}/authorize`,
+            token_endpoint: `${authenticationDomain}/oauth/token`,
+            userinfo_endpoint: `${authenticationDomain}/userinfo`,
+            end_session_endpoint: `${authenticationDomain}/v2/logout` +
+                `?returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}` +
+                `&client_id=${oidcConfiguration.clientId}`,
         },
-    });
-    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,
+        mergeClaims: true,
+        loadUserInfo: true,
+        scope: oidcConfiguration.scope,
     };
-}
-async function batchTransfer({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const ethAddress = await ethSigner.getAddress();
-    const transfersApi = new TransfersApi(config.getStarkExConfig().apiConfiguration);
-    const signableRequests = request.map((nftTransfer) => {
-        return {
-            amount: '1',
-            token: convertToSignableToken({
-                type: 'ERC721',
-                tokenId: nftTransfer.tokenId,
-                tokenAddress: nftTransfer.tokenAddress,
-            }),
-            receiver: nftTransfer.receiver,
+    if (oidcConfiguration.audience) {
+        baseConfiguration.extraQueryParams = {
+            audience: oidcConfiguration.audience,
         };
-    });
-    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);
+    return baseConfiguration;
+};
+class AuthManager {
+    userManager;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.userManager = new UserManager(getAuthConfiguration(config));
     }
-    // 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,
+    mapOidcUserToDomainModel = (oidcUser) => {
+        const passport = oidcUser.profile?.passport;
+        return {
+            expired: oidcUser.expired,
+            idToken: oidcUser.id_token,
+            accessToken: oidcUser.access_token,
+            refreshToken: oidcUser.refresh_token,
+            profile: {
+                sub: oidcUser.profile.sub,
+                email: oidcUser.profile.email,
+                nickname: oidcUser.profile.nickname,
+            },
+            etherKey: passport?.ether_key || '',
+        };
     };
+    async login() {
+        return withPassportError(async () => {
+            const popupWindowFeatures = { width: 410, height: 450 };
+            const oidcUser = await this.userManager.signinPopup({
+                popupWindowFeatures,
+            });
+            return this.mapOidcUserToDomainModel(oidcUser);
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    async loginCallback() {
+        return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    async logout() {
+        return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
+    }
+    async 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) {
+                return null;
+            }
+            return this.mapOidcUserToDomainModel(oidcUser);
+        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
+    }
+    async requestRefreshTokenAfterRegistration() {
+        return withPassportError(async () => {
+            const updatedUser = await retryWithDelay(async () => {
+                const user = await this.userManager.signinSilent();
+                const passportMetadata = user?.profile?.passport;
+                const metadataExists = !!passportMetadata?.ether_key &&
+                    !!passportMetadata?.stark_key &&
+                    !!passportMetadata?.user_admin_key;
+                if (metadataExists) {
+                    return user;
+                }
+                return Promise.reject('user wallet addresses not exist');
+            });
+            if (!updatedUser) {
+                return null;
+            }
+            return this.mapOidcUserToDomainModel(updatedUser);
+        }, PassportErrorType.REFRESH_TOKEN_ERROR);
+    }
 }
 
-async function createOrder$1({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.getStarkExConfig());
-    const ethAddress = await signers.ethSigner.getAddress();
-    const ordersApi = new OrdersApi(config.getStarkExConfig().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.getStarkExConfig().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.getStarkExConfig());
-    const usersApi = new UsersApi(config.getStarkExConfig().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.getStarkExConfig());
-    const registrationContract = Contracts.Registration.connect(config.getStarkExConfig().ethConfiguration.registrationContractAddress, ethSigner);
-    try {
-        return await registrationContract.isRegistered(starkPublicKey);
+class MagicAdapter {
+    magicClient;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.magicClient = new Magic(config.magicPublishableApiKey, {
+            network: config.network,
+            extensions: [new OpenIdExtension()],
+        });
     }
-    catch (ex) {
-        if (ex.reason === 'USER_UNREGISTERED') {
-            return false;
-        }
-        throw ex;
+    async login(idToken) {
+        return withPassportError(async () => {
+            await this.magicClient.openid.loginWithOIDC({
+                jwt: idToken,
+                providerId: this.config.magicProviderId,
+            });
+            return new ethers.providers.Web3Provider(this.magicClient
+                .rpcProvider);
+        }, PassportErrorType.WALLET_CONNECTION_ERROR);
     }
 }
-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;
-}
+var ReceiveMessage;
+(function (ReceiveMessage) {
+    ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
+    ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
+    ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
+})(ReceiveMessage || (ReceiveMessage = {}));
+var SendMessage;
+(function (SendMessage) {
+    SendMessage["TRANSACTION_START"] = "transaction_start";
+})(SendMessage || (SendMessage = {}));
+var TransactionTypes;
+(function (TransactionTypes) {
+    TransactionTypes["CancelOrder"] = "delete:v1/orders";
+    TransactionTypes["CreateOrder"] = "post:v1/orders";
+    TransactionTypes["CreateTrade"] = "post:v1/trades";
+    TransactionTypes["CreateTransfer"] = "post:v1/transfers";
+    TransactionTypes["CreateBatchTransfer"] = "post:v2/transfers";
+})(TransactionTypes || (TransactionTypes = {}));
+const PassportEventType = 'imx_passport_confirmation';
 
-async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
-    const etherKey = await ethSigner.getAddress();
-    const starkExConfig = config.getStarkExConfig();
-    const usersApi = new UsersApi(starkExConfig.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.getStarkExConfig().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.getStarkExConfig());
-    const starkExConfig = config.getStarkExConfig();
-    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);
+const openPopupCenter = ({ url, title, width, height, }) => {
+    const left = Math.max(0, Math.round(window.screenX + (window.outerWidth - width) / 2));
+    const top = Math.max(0, Math.round(window.screenY + (window.outerHeight - height) / 2));
+    const newWindow = window.open(url, title, `
+      scrollbars=yes,
+      width=${width}, 
+      height=${height}, 
+      top=${top}, 
+      left=${left}
+     `);
+    if (!newWindow) {
+        throw new Error('Failed to open confirmation screen');
     }
-}
+    newWindow.focus();
+    return newWindow;
+};
 
-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.getStarkExConfig();
-    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);
+const ConfirmationWindowTitle = 'Confirm this transaction';
+const ConfirmationWindowHeight = 380;
+const ConfirmationWindowWidth = 480;
+const ConfirmationWindowClosedPollingDuration = 1000;
+class ConfirmationScreen {
+    config;
+    constructor(config) {
+        this.config = config;
     }
-    else {
-        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, starkExConfig);
+    postMessage(destinationWindow, accessToken, message) {
+        destinationWindow.postMessage({
+            eventType: PassportEventType,
+            accessToken,
+            ...message,
+        }, this.config.passportDomain);
     }
-}
-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.getStarkExConfig();
-    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.getStarkExConfig());
-    const tokenAddress = token.tokenAddress;
-    const tokenId = token.tokenId;
-    const starkExConfig = config.getStarkExConfig();
-    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.getStarkExConfig());
-    const starkExConfig = config.getStarkExConfig();
-    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);
+    startTransaction(accessToken, transaction, popupOptions) {
+        return new Promise((resolve, reject) => {
+            const messageHandler = ({ data, origin }) => {
+                if (origin != this.config.passportDomain ||
+                    data.eventType != PassportEventType) {
+                    return;
+                }
+                switch (data.messageType) {
+                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
+                        this.postMessage(confirmationWindow, accessToken, {
+                            messageType: SendMessage.TRANSACTION_START,
+                            messageData: transaction,
+                        });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
+                        resolve({ confirmed: true });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_ERROR: {
+                        reject(new Error('Transaction error'));
+                        break;
+                    }
+                    default:
+                        reject(new Error('Unsupported message type'));
+                }
+            };
+            window.addEventListener('message', messageHandler);
+            const confirmationWindow = openPopupCenter({
+                url: `${this.config.passportDomain}/transaction-confirmation`,
+                title: ConfirmationWindowTitle,
+                width: popupOptions?.width || ConfirmationWindowWidth,
+                height: popupOptions?.height || ConfirmationWindowHeight,
+            });
+            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
+            const timer = setInterval(function () {
+                if (confirmationWindow.closed) {
+                    clearInterval(timer);
+                    window.removeEventListener('message', messageHandler);
+                    resolve({ confirmed: false });
+                }
+            }, ConfirmationWindowClosedPollingDuration);
+        });
     }
 }
 
-async function prepareWithdrawal({ signers, withdrawal, config, }) {
-    const starkExConfig = config.getStarkExConfig();
-    return prepareWithdrawalAction({
-        signers,
-        config: starkExConfig,
-        ...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,
-            });
-    }
+const ERC721$1 = 'ERC721';
+const transfer$1 = ({ request, transfersApi, starkSigner, user, passportConfig, }) => {
+    return withPassportError(async () => {
+        const transferAmount = request.type === ERC721$1 ? '1' : request.amount;
+        const getSignableTransferRequest = {
+            sender: user.etherKey,
+            token: convertToSignableToken(request),
+            amount: transferAmount,
+            receiver: request.receiver,
+        };
+        const signableResult = await transfersApi.getSignableTransferV1({
+            getSignableTransferRequest,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateTransfer,
+            transactionData: getSignableTransferRequest,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const signableResultData = signableResult.data;
+        const { payload_hash: payloadHash } = signableResultData;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const senderStarkKey = await starkSigner.getAddress();
+        const transferSigningParams = {
+            sender_stark_key: signableResultData.sender_stark_key || senderStarkKey,
+            sender_vault_id: signableResultData.sender_vault_id,
+            receiver_stark_key: signableResultData.receiver_stark_key,
+            receiver_vault_id: signableResultData.receiver_vault_id,
+            asset_id: signableResultData.asset_id,
+            amount: signableResultData.amount,
+            nonce: signableResultData.nonce,
+            expiration_timestamp: signableResultData.expiration_timestamp,
+            stark_signature: starkSignature,
+        };
+        const createTransferRequest = {
+            createTransferRequest: transferSigningParams,
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const { data: responseData } = await transfersApi.createTransferV1(createTransferRequest, { headers });
+        return {
+            sent_signature: responseData.sent_signature,
+            status: responseData.status?.toString(),
+            time: responseData.time,
+            transfer_id: responseData.transfer_id,
+        };
+    }, PassportErrorType.TRANSFER_ERROR);
+};
+async function batchNftTransfer({ user, starkSigner, request, transfersApi, passportConfig, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const signableRequests = request.map((nftTransfer) => {
+            return {
+                amount: '1',
+                token: convertToSignableToken({
+                    type: ERC721$1,
+                    tokenId: nftTransfer.tokenId,
+                    tokenAddress: nftTransfer.tokenAddress,
+                }),
+                receiver: nftTransfer.receiver,
+            };
+        });
+        const getSignableTransferRequestV2 = {
+            sender_ether_key: ethAddress,
+            signable_requests: signableRequests,
+        };
+        const signableResult = await transfersApi.getSignableTransfer({
+            getSignableTransferRequestV2,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const popupWindowSize = { width: 480, height: 784 };
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateBatchTransfer,
+            transactionData: getSignableTransferRequestV2,
+        }, popupWindowSize);
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
+            const starkSignature = await starkSigner.signMessage(resp.payload_hash);
+            return {
+                sender_vault_id: resp.sender_vault_id,
+                receiver_stark_key: resp.receiver_stark_key,
+                receiver_vault_id: resp.receiver_vault_id,
+                asset_id: resp.asset_id,
+                amount: resp.amount,
+                nonce: resp.nonce,
+                expiration_timestamp: resp.expiration_timestamp,
+                stark_signature: starkSignature,
+            };
+        }));
+        const transferSigningParams = {
+            sender_stark_key: signableResult.data.sender_stark_key,
+            requests,
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const response = await transfersApi.createTransfer({
+            createTransferRequestV2: transferSigningParams,
+        }, { headers });
+        return {
+            transfer_ids: response?.data.transfer_ids,
+        };
+    }, PassportErrorType.TRANSFER_ERROR);
 }
 
-async function createTrade$1({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const ethAddress = await ethSigner.getAddress();
-    const tradesApi = new TradesApi(config.getStarkExConfig().apiConfiguration);
-    const signableResult = await tradesApi.getSignableTrade({
-        getSignableTradeRequest: {
+const ERC721 = 'ERC721';
+async function createOrder$1({ starkSigner, user, request, ordersApi, passportConfig, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const amountSell = request.sell.type === ERC721 ? '1' : request.sell.amount;
+        const amountBuy = request.buy.type === ERC721 ? '1' : request.buy.amount;
+        const getSignableOrderRequestV3 = {
             user: ethAddress,
-            order_id: request.order_id,
+            amount_buy: amountBuy,
+            token_buy: convertToSignableToken(request.buy),
+            amount_sell: amountSell,
+            token_sell: convertToSignableToken(request.sell),
             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.getStarkExConfig());
-    const user = await ethSigner.getAddress();
-    const data = {
-        decimals: 18,
-    };
-    const amount = parseUnits(deposit.amount, 'wei');
-    const starkExConfig = config.getStarkExConfig();
-    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,
+            expiration_timestamp: request.expiration_timestamp,
+        };
+        const getSignableOrderResponse = await ordersApi.getSignableOrder({
+            getSignableOrderRequestV3,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateOrder,
+            transactionData: getSignableOrderRequestV3,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const { payload_hash: payloadHash } = getSignableOrderResponse.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const signableResultData = getSignableOrderResponse.data;
+        const orderParams = {
+            createOrderRequest: {
+                include_fees: true,
+                fees: request.fees,
+                stark_signature: starkSignature,
+                amount_buy: signableResultData.amount_buy,
+                amount_sell: signableResultData.amount_sell,
+                asset_id_buy: signableResultData.asset_id_buy,
+                asset_id_sell: signableResultData.asset_id_sell,
+                expiration_timestamp: signableResultData.expiration_timestamp,
+                nonce: signableResultData.nonce,
+                stark_key: signableResultData.stark_key,
+                vault_id_buy: signableResultData.vault_id_buy,
+                vault_id_sell: signableResultData.vault_id_sell,
             },
-        },
-    });
-    const 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 });
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const createOrderResponse = await ordersApi.createOrder(orderParams, {
+            headers,
+        });
+        return {
+            ...createOrderResponse.data,
+        };
+    }, PassportErrorType.CREATE_ORDER_ERROR);
 }
-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 cancelOrder$1({ user, starkSigner, request, ordersApi, passportConfig, }) {
+    return withPassportError(async () => {
+        const getSignableCancelOrderRequest = {
+            order_id: request.order_id,
+        };
+        const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
+            getSignableCancelOrderRequest,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CancelOrder,
+            transactionData: getSignableCancelOrderRequest,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const cancelOrderResponse = await ordersApi.cancelOrder({
+            id: request.order_id.toString(),
+            cancelOrderRequest: {
+                order_id: request.order_id,
+                stark_signature: starkSignature,
+            },
+        }, { headers });
+        return {
+            order_id: cancelOrderResponse.data.order_id,
+            status: cancelOrderResponse.data.status,
+        };
+    }, PassportErrorType.CANCEL_ORDER_ERROR);
 }
 
-async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const { apiConfiguration, ethConfiguration } = config.getStarkExConfig();
-    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,
-                },
+async function exchangeTransfer$1({ user, starkSigner, request, exchangesApi, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const transferAmount = request.amount;
+        const signableResult = await exchangesApi.getExchangeSignableTransfer({
+            id: request.transactionID,
+            getSignableTransferRequest: {
+                sender: ethAddress,
+                token: convertToSignableToken(request),
+                amount: transferAmount,
+                receiver: request.receiver,
             },
-        },
-    });
-    const 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);
+        });
+        const starkAddress = await starkSigner.getAddress();
+        const { payload_hash: payloadHash } = signableResult.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const transferSigningParams = {
+            sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
+            sender_vault_id: signableResult.data.sender_vault_id,
+            receiver_stark_key: signableResult.data.receiver_stark_key,
+            receiver_vault_id: signableResult.data.receiver_vault_id,
+            asset_id: signableResult.data.asset_id,
+            amount: signableResult.data.amount,
+            nonce: signableResult.data.nonce,
+            expiration_timestamp: signableResult.data.expiration_timestamp,
+            stark_signature: starkSignature,
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const response = await exchangesApi.createExchangeTransfer({
+            id: request.transactionID,
+            createTransferRequest: transferSigningParams,
+        }, { headers });
+        return {
+            sent_signature: response?.data.sent_signature,
+            status: response?.data.status?.toString(),
+            time: response?.data.time,
+            transfer_id: response?.data.transfer_id,
+        };
+    }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
 }
 
-async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.getStarkExConfig());
-    const user = await ethSigner.getAddress();
-    const starkExConfig = config.getStarkExConfig();
-    const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
-    const usersApi = new UsersApi(starkExConfig.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,
-                },
+async function createTrade$1({ request, tradesApi, user, starkSigner, passportConfig, }) {
+    return withPassportError(async () => {
+        const ethAddress = user.etherKey;
+        const getSignableTradeRequest = {
+            expiration_timestamp: request.expiration_timestamp,
+            fees: request.fees,
+            order_id: request.order_id,
+            user: ethAddress,
+        };
+        const getSignableTradeResponse = await tradesApi.getSignableTrade({
+            getSignableTradeRequest,
+        });
+        const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+            transactionType: TransactionTypes.CreateTrade,
+            transactionData: getSignableTradeRequest,
+        });
+        if (!confirmationResult.confirmed) {
+            throw new Error('Transaction rejected by user');
+        }
+        const { payload_hash: payloadHash } = getSignableTradeResponse.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const { data: signableResultData } = getSignableTradeResponse;
+        const tradeParams = {
+            createTradeRequest: {
+                include_fees: true,
+                fees: request?.fees,
+                stark_signature: starkSignature,
+                order_id: request?.order_id,
+                fee_info: signableResultData.fee_info,
+                amount_buy: signableResultData.amount_buy,
+                amount_sell: signableResultData.amount_sell,
+                asset_id_buy: signableResultData.asset_id_buy,
+                asset_id_sell: signableResultData.asset_id_sell,
+                expiration_timestamp: signableResultData.expiration_timestamp,
+                nonce: signableResultData.nonce,
+                stark_key: signableResultData.stark_key,
+                vault_id_buy: signableResultData.vault_id_buy,
+                vault_id_sell: signableResultData.vault_id_sell,
             },
-        },
-    });
-    const 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 = starkExConfig.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(starkExConfig.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, starkExConfig);
-}
-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.getStarkExConfig());
-    const exchangeApi = new ExchangesApi(config.getStarkExConfig().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,
-    };
+        };
+        const headers = { Authorization: 'Bearer ' + user.accessToken };
+        const { data: createTradeResponse } = await tradesApi.createTradeV3(tradeParams, {
+            headers,
+        });
+        return createTradeResponse;
+    }, PassportErrorType.CREATE_TRADE_ERROR);
 }
 
-class GenericIMXProvider {
-    config;
-    signers;
-    constructor(config, ethSigner, starkExSigner) {
-        this.config = config;
-        this.signers = { ethSigner, starkExSigner };
+class PassportImxProvider {
+    user;
+    starkSigner;
+    transfersApi;
+    ordersApi;
+    passportConfig;
+    exchangesApi;
+    tradesApi;
+    constructor({ user, starkSigner, passportConfig }) {
+        this.user = user;
+        this.starkSigner = starkSigner;
+        this.passportConfig = passportConfig;
+        const apiConfig = new Configuration({
+            basePath: passportConfig.imxApiBasePath,
+        });
+        this.transfersApi = new TransfersApi(apiConfig);
+        this.ordersApi = new OrdersApi(apiConfig);
+        this.exchangesApi = new ExchangesApi(apiConfig);
+        this.tradesApi = new TradesApi(apiConfig);
     }
-    async getAddress() {
-        return await this.signers.ethSigner.getAddress();
+    async transfer(request) {
+        return transfer$1({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            transfersApi: this.transfersApi,
+            passportConfig: this.passportConfig,
+        });
     }
     registerOffchain() {
-        return registerOffchain(this.signers, this.config);
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    batchNftTransfer(request) {
-        return batchTransfer({
-            signers: this.signers,
+    isRegisteredOnchain() {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    createOrder(request) {
+        return createOrder$1({
             request,
-            config: this.config,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            ordersApi: this.ordersApi,
+            passportConfig: this.passportConfig,
         });
     }
     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,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            ordersApi: this.ordersApi,
+            passportConfig: this.passportConfig,
         });
     }
     createTrade(request) {
         return createTrade$1({
-            signers: this.signers,
             request,
-            config: this.config,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            tradesApi: this.tradesApi,
+            passportConfig: this.passportConfig,
         });
     }
-    deposit(tokenAmount) {
-        return deposit({
-            signers: this.signers,
-            deposit: tokenAmount,
-            config: this.config,
+    batchNftTransfer(request) {
+        return batchNftTransfer({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            transfersApi: this.transfersApi,
+            passportConfig: this.passportConfig,
         });
     }
     exchangeTransfer(request) {
         return exchangeTransfer$1({
-            signers: this.signers,
             request,
-            config: this.config,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            exchangesApi: this.exchangesApi,
         });
     }
-    async isRegisteredOnchain() {
-        const starkPublicKey = await this.signers.starkExSigner.getAddress();
-        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    deposit(deposit) {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     prepareWithdrawal(request) {
-        return prepareWithdrawal({
-            signers: this.signers,
-            withdrawal: request,
-            config: this.config,
-        });
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    transfer(request) {
-        return transfer$1({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
+    completeWithdrawal(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    starkPublicKey, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    token) {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    getAddress() {
+        return Promise.resolve(this.starkSigner.getAddress());
     }
 }
 
-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)}` }],
-        });
-    }
-}
+var Networks;
+(function (Networks) {
+    Networks["PRODUCTION"] = "mainnet";
+    Networks["SANDBOX"] = "goerli";
+})(Networks || (Networks = {}));
 
-const ERRORS = {
-    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
+const validateConfiguration = (configuration, requiredKeys, prefix) => {
+    const missingKeys = requiredKeys
+        .map((key) => !configuration[key] && key)
+        .filter((n) => n)
+        .join(', ');
+    if (missingKeys !== '') {
+        const errorMessage = prefix
+            ? `${prefix} - ${missingKeys} cannot be null`
+            : `${missingKeys} cannot be null`;
+        throw new PassportError(errorMessage, PassportErrorType.INVALID_CONFIGURATION);
+    }
 };
-async function connect$1({ chainID, }) {
-    const provider = (await detectEthereumProvider());
-    if (!isRequestableProvider(provider)) {
-        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
+class PassportConfiguration {
+    network;
+    authenticationDomain;
+    passportDomain;
+    magicPublishableApiKey;
+    magicProviderId;
+    imxApiBasePath;
+    oidcConfiguration;
+    baseConfig;
+    constructor({ baseConfig, overrides, ...oidcConfiguration }) {
+        validateConfiguration(oidcConfiguration, [
+            'clientId',
+            'logoutRedirectUri',
+            'redirectUri',
+        ]);
+        this.oidcConfiguration = oidcConfiguration;
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            validateConfiguration(overrides, [
+                'network',
+                'authenticationDomain',
+                'magicPublishableApiKey',
+                'magicProviderId',
+                'passportDomain',
+                'imxApiBasePath',
+            ], 'overrides');
+            this.network = overrides.network;
+            this.authenticationDomain = overrides.authenticationDomain;
+            this.passportDomain = overrides.passportDomain;
+            this.magicPublishableApiKey = overrides.magicPublishableApiKey;
+            this.magicProviderId = overrides.magicProviderId;
+            this.imxApiBasePath = overrides.imxApiBasePath;
+        }
+        else {
+            switch (baseConfig.environment) {
+                case Environment.SANDBOX: {
+                    this.network = Networks.SANDBOX;
+                    this.authenticationDomain = 'https://auth.immutable.com';
+                    this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
+                    this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
+                    this.passportDomain = 'https://passport.sandbox.immutable.com';
+                    this.imxApiBasePath = 'https://api.sandbox.x.immutable.com';
+                    break;
+                }
+                case Environment.PRODUCTION: {
+                    this.network = Networks.PRODUCTION;
+                    this.authenticationDomain = 'https://auth.immutable.com';
+                    this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
+                    this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
+                    this.passportDomain = 'https://passport.immutable.com';
+                    this.imxApiBasePath = 'https://api.x.immutable.com';
+                    break;
+                }
+            }
+        }
     }
-    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 = {}));
+const getStarkSigner = async (signer) => {
+    return withPassportError(async () => {
+        const privateKey = await generateLegacyStarkPrivateKey(signer);
+        return createStarkSigner(privateKey);
+    }, PassportErrorType.WALLET_CONNECTION_ERROR);
+};
 
-function postRequestMessage(iframe, payload) {
-    if (iframe && iframe.contentWindow) {
-        iframe.contentWindow.postMessage(payload, new URL(iframe.src).origin);
-    }
+async function registerPassport({ ethSigner, starkSigner, usersApi }, authorization) {
+    return withPassportError(async () => {
+        const userAddress = await ethSigner.getAddress();
+        const starkPublicKey = await starkSigner.getAddress();
+        const signableResult = await usersApi.getSignableRegistrationOffchain({
+            getSignableRegistrationRequest: {
+                ether_key: userAddress,
+                stark_key: starkPublicKey,
+            },
+        });
+        const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+        const ethSignature = await signRaw(signableMessage, ethSigner);
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const response = await usersApi.registerPassportUser({
+            authorization: `Bearer ` + authorization,
+            registerPassportUserRequest: {
+                eth_signature: ethSignature,
+                ether_key: userAddress,
+                stark_signature: starkSignature,
+                stark_key: starkPublicKey,
+            },
+        });
+        return response.statusText;
+    }, PassportErrorType.USER_REGISTRATION_ERROR);
 }
 
-function messageResponseListener(iframe, event, eventType, callback) {
-    if (iframe && event.source !== iframe.contentWindow) {
-        return;
+class Passport {
+    authManager;
+    magicAdapter;
+    config;
+    constructor(passportModuleConfiguration) {
+        const passportConfiguration = new PassportConfiguration(passportModuleConfiguration);
+        this.config = passportConfiguration;
+        this.authManager = new AuthManager(this.config);
+        this.magicAdapter = new MagicAdapter(this.config);
     }
-    const l2WalletMessage = event.data;
-    if (l2WalletMessage.type !== eventType) {
-        return;
+    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);
+        const ethSigner = provider.getSigner();
+        const starkSigner = await getStarkSigner(ethSigner);
+        if (!user.etherKey) {
+            const updatedUser = await this.registerUser(ethSigner, starkSigner, user.accessToken);
+            return new PassportImxProvider({
+                user: updatedUser,
+                starkSigner,
+                passportConfig: this.config,
+            });
+        }
+        const userWithEtherKey = user;
+        return new PassportImxProvider({
+            user: userWithEtherKey,
+            starkSigner,
+            passportConfig: this.config,
+        });
     }
-    callback(l2WalletMessage.details);
-}
-
-class ImxSigner {
-    publicAddress;
-    iframe;
-    constructor(publicAddress, iframe) {
-        this.publicAddress = publicAddress;
-        this.iframe = iframe;
+    async connectImxSilent() {
+        const user = await this.authManager.loginSilent();
+        if (!user) {
+            return null;
+        }
+        return this.getImxProvider(user);
     }
-    getAddress() {
-        return this.publicAddress;
+    async connectImx() {
+        const user = await this.authManager.login();
+        return this.getImxProvider(user);
     }
-    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 },
-            });
-        });
+    async loginCallback() {
+        return this.authManager.loginCallback();
     }
-    getIFrame() {
-        return this.iframe;
+    async logout() {
+        return this.authManager.logout();
+    }
+    async getUserInfo() {
+        const user = await this.authManager.getUser();
+        return user?.profile;
+    }
+    async getIdToken() {
+        const user = await this.authManager.getUser();
+        return user?.idToken;
+    }
+    async getAccessToken() {
+        const user = await this.authManager.getUser();
+        return user?.accessToken;
+    }
+    async registerUser(userAdminKeySigner, starkSigner, jwt) {
+        const configuration = new Configuration({
+            basePath: this.config.imxApiBasePath,
+        });
+        const usersApi = new UsersApi(configuration);
+        await registerPassport({
+            ethSigner: userAdminKeySigner,
+            starkSigner,
+            usersApi,
+        }, jwt);
+        const updatedUser = await this.authManager.requestRefreshTokenAfterRegistration();
+        if (!updatedUser) {
+            throw new PassportError('Failed to get refresh token', PassportErrorType.REFRESH_TOKEN_ERROR);
+        }
+        return updatedUser;
     }
 }
 
-const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
-const IMX_WALLET_IFRAME_HOSTS = {
-    [Environment.DEVELOPMENT]: 'http://localhost:8080',
-    [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);
-    });
+function isChainValid(chainID, config) {
+    return chainID === config.ethConfiguration.chainID;
 }
-async function getOrSetupIFrame(env) {
-    const iframe = getIFrame();
-    if (iframe)
-        return iframe;
-    return await setupIFrame(env);
+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.');
 }
 
-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 transfer({ signers: { ethSigner, starkSigner }, 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 starkSigner.signMessage(payloadHash);
+    const transferSigningParams = {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        sender_stark_key: signableResult.data.sender_stark_key,
+        sender_vault_id: signableResult.data.sender_vault_id,
+        receiver_stark_key: signableResult.data.receiver_stark_key,
+        receiver_vault_id: signableResult.data.receiver_vault_id,
+        asset_id: signableResult.data.asset_id,
+        amount: signableResult.data.amount,
+        nonce: signableResult.data.nonce,
+        expiration_timestamp: signableResult.data.expiration_timestamp,
+        stark_signature: starkSignature,
+    };
+    const response = await transfersApi.createTransferV1({
+        createTransferRequest: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
     });
+    return {
+        sent_signature: response?.data.sent_signature,
+        status: response?.data.status?.toString(),
+        time: response?.data.time,
+        transfer_id: response?.data.transfer_id,
+    };
 }
-async function 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();
-            });
+async function batchTransfer({ signers: { ethSigner, starkSigner }, 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,
         };
-        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) {
-        const starkExConfig = config.getStarkExConfig();
-        return await withProviderError(async () => {
-            const metaMaskProvider = await connect$1({
-                chainID: starkExConfig.ethConfiguration.chainID,
-            });
-            this.imxSigner = await connect(metaMaskProvider, starkExConfig.env);
-            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 });
+    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');
     }
-    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 });
+    const ethSignature = await signRaw(signableMessage, ethSigner);
+    const requests = [];
+    for (const resp of signableResult.data.signable_responses) {
+        const starkSignature = await starkSigner.signMessage(resp.payload_hash);
+        const req = {
+            sender_vault_id: resp.sender_vault_id,
+            receiver_stark_key: resp.receiver_stark_key,
+            receiver_vault_id: resp.receiver_vault_id,
+            asset_id: resp.asset_id,
+            amount: resp.amount,
+            nonce: resp.nonce,
+            expiration_timestamp: resp.expiration_timestamp,
+            stark_signature: starkSignature,
+        };
+        requests.push(req);
     }
+    // TODO: throw error on missing payload hash?
+    const transferSigningParams = {
+        sender_stark_key: signableResult.data.sender_stark_key,
+        requests,
+    };
+    const response = await transfersApi.createTransfer({
+        createTransferRequestV2: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        transfer_ids: response?.data.transfer_ids,
+    };
 }
 
-var PassportErrorType;
-(function (PassportErrorType) {
-    PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
-    PassportErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
-    PassportErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
-    PassportErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
-    PassportErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
-    PassportErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
-    PassportErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
-    PassportErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
-    PassportErrorType["CREATE_ORDER_ERROR"] = "CREATE_ORDER_ERROR";
-    PassportErrorType["CANCEL_ORDER_ERROR"] = "CANCEL_ORDER_ERROR";
-    PassportErrorType["EXCHANGE_TRANSFER_ERROR"] = "EXCHANGE_TRANSFER_ERROR";
-    PassportErrorType["CREATE_TRADE_ERROR"] = "CREATE_TRADE_ERROR";
-    PassportErrorType["OPERATION_NOT_SUPPORTED_ERROR"] = "OPERATION_NOT_SUPPORTED_ERROR";
-})(PassportErrorType || (PassportErrorType = {}));
-class PassportError extends Error {
-    type;
-    constructor(message, type) {
-        super(message);
-        this.type = type;
-    }
+async function createOrder({ 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.starkSigner.signMessage(payloadHash);
+    const resp = getSignableOrderResponse.data;
+    const orderParams = {
+        createOrderRequest: {
+            amount_buy: resp.amount_buy,
+            amount_sell: resp.amount_sell,
+            asset_id_buy: resp.asset_id_buy,
+            asset_id_sell: resp.asset_id_sell,
+            expiration_timestamp: resp.expiration_timestamp,
+            include_fees: true,
+            fees: request.fees,
+            nonce: resp.nonce,
+            stark_key: resp.stark_key,
+            stark_signature: starkSignature,
+            vault_id_buy: resp.vault_id_buy,
+            vault_id_sell: resp.vault_id_sell,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    };
+    const createOrderResponse = await ordersApi.createOrder(orderParams);
+    return {
+        ...createOrderResponse.data,
+    };
+}
+async function cancelOrder({ signers, request, config, }) {
+    const ordersApi = new OrdersApi(config.immutableXConfig.apiConfiguration);
+    const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
+        getSignableCancelOrderRequest: {
+            order_id: request.order_id,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const ethAddress = await signers.ethSigner.getAddress();
+    const cancelOrderResponse = await ordersApi.cancelOrder({
+        id: request.order_id.toString(),
+        cancelOrderRequest: {
+            order_id: request.order_id,
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        order_id: cancelOrderResponse.data.order_id,
+        status: cancelOrderResponse.data.status,
+    };
 }
-const withPassportError = async (fn, customErrorType) => {
-    try {
-        return await fn();
-    }
-    catch (error) {
-        const errorMessage = `${customErrorType}: ${error.message}` || 'UnknownError';
-        throw new PassportError(errorMessage, customErrorType);
-    }
-};
 
-const POLL_INTERVAL = 1 * 1000; // every 1 second
-const MAX_RETRIES = 3;
-const wait = (ms) => new Promise((resolve) => {
-    setTimeout(() => resolve(), ms);
-});
-const retryWithDelay = async (fn, options) => {
-    const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), } = options || {};
+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.starkSigner.getAddress();
+    const signableResult = await usersApi.getSignableRegistrationOffchain({
+        getSignableRegistrationRequest: {
+            ether_key: userAddress,
+            stark_key: starkPublicKey,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const registeredUser = await usersApi.registerUser({
+        registerUserRequest: {
+            eth_signature: ethSignature,
+            ether_key: userAddress,
+            stark_signature: starkSignature,
+            stark_key: starkPublicKey,
+        },
+    });
+    return registeredUser.data;
+}
+async function isRegisteredOnChain(starkPublicKey, ethSigner, config) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const registrationContract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
     try {
-        return await fn();
+        return await registrationContract.isRegistered(starkPublicKey);
     }
-    catch (err) {
-        if (retries <= 0) {
-            return Promise.reject(finalErr);
+    catch (ex) {
+        if (ex.reason === 'USER_UNREGISTERED') {
+            return false;
         }
-        await wait(interval);
-        return retryWithDelay(fn, { retries: retries - 1, finalErr });
+        throw ex;
     }
-};
-
-const getAuthConfiguration = ({ oidcConfiguration, }) => {
-    const baseConfiguration = {
-        authority: oidcConfiguration.authenticationDomain,
-        redirect_uri: oidcConfiguration.redirectUri,
-        popup_redirect_uri: oidcConfiguration.redirectUri,
-        client_id: oidcConfiguration.clientId,
-        metadata: {
-            authorization_endpoint: `${oidcConfiguration.authenticationDomain}/authorize`,
-            token_endpoint: `${oidcConfiguration.authenticationDomain}/oauth/token`,
-            userinfo_endpoint: `${oidcConfiguration.authenticationDomain}/userinfo`,
-            end_session_endpoint: `${oidcConfiguration.authenticationDomain}/v2/logout` +
-                `?returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}` +
-                `&client_id=${oidcConfiguration.clientId}`,
-        },
-        mergeClaims: true,
-        loadUserInfo: true,
-        scope: oidcConfiguration.scope,
+}
+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,
     };
-    if (oidcConfiguration.audience) {
-        baseConfiguration.extraQueryParams = {
-            audience: oidcConfiguration.audience,
-        };
-    }
-    return baseConfiguration;
+}
+
+const assertIsDefined = (value) => {
+    if (value !== undefined)
+        return value;
+    throw new Error('undefined field exception');
 };
-class AuthManager {
-    userManager;
-    config;
-    constructor(config) {
-        this.config = config;
-        this.userManager = new UserManager(getAuthConfiguration(config));
-    }
-    mapOidcUserToDomainModel = (oidcUser) => {
-        const passport = oidcUser.profile?.passport;
-        return {
-            idToken: oidcUser.id_token,
-            accessToken: oidcUser.access_token,
-            refreshToken: oidcUser.refresh_token,
-            profile: {
-                sub: oidcUser.profile.sub,
-                email: oidcUser.profile.email,
-                nickname: oidcUser.profile.nickname,
+async function prepareWithdrawalAction(params) {
+    const { signers: { ethSigner, starkSigner }, 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 starkSigner.signMessage(payloadHash);
+    const { ethAddress, ethSignature } = await signMessage(signableMessage, ethSigner);
+    const prepareWithdrawalResponse = await withdrawalsApi.createWithdrawal({
+        createWithdrawalRequest: {
+            stark_key: assertIsDefined(signableWithdrawalResult.data.stark_key),
+            amount: withdrawalAmount,
+            asset_id: assertIsDefined(signableWithdrawalResult.data.asset_id),
+            vault_id: assertIsDefined(signableWithdrawalResult.data.vault_id),
+            nonce: assertIsDefined(signableWithdrawalResult.data.nonce),
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return prepareWithdrawalResponse.data;
+}
+
+async function getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
+    const encodingApi = new EncodingApi(config.apiConfiguration);
+    const result = await encodingApi.encodeAsset({
+        assetType,
+        encodeAssetRequest: {
+            token: {
+                type: tokenType,
+                ...(tokenData && { data: tokenData }),
             },
-            etherKey: passport?.ether_key || '',
-        };
-    };
-    async login() {
-        return withPassportError(async () => {
-            const oidcUser = await this.userManager.signinPopup();
-            return this.mapOidcUserToDomainModel(oidcUser);
-        }, PassportErrorType.AUTHENTICATION_ERROR);
+        },
+    });
+    return result.data;
+}
+
+async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
+    const etherKey = await ethSigner.getAddress();
+    const imxConfig = config.immutableXConfig;
+    const usersApi = new UsersApi(imxConfig.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 imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC20', imxConfig, {
+        token_address: token.tokenAddress,
+    });
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawERC20({
+            ethSigner,
+            assetType: assetType.asset_type,
+            starkPublicKey,
+            config,
+        });
     }
-    async loginCallback() {
-        return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
+    else {
+        return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
-    async logout() {
-        return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
+}
+
+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 imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', imxConfig, {
+        id: token.data.id,
+        token_address: token.data.tokenAddress,
+        ...(token.data.blueprint && { blueprint: token.data.blueprint }),
+    });
+    const mintingBlob = getMintingBlob(token);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
-    async getUser() {
-        return withPassportError(async () => {
-            const oidcUser = await this.userManager.getUser();
-            if (!oidcUser) {
-                throw new Error('Failed to retrieve user');
-            }
-            return this.mapOidcUserToDomainModel(oidcUser);
-        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
+    else {
+        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
-    async requestRefreshTokenAfterRegistration() {
-        return withPassportError(async () => {
-            const updatedUser = await retryWithDelay(async () => {
-                const user = await this.userManager.signinSilent();
-                const passportMetadata = user?.profile?.passport;
-                const metadataExists = !!passportMetadata?.ether_key &&
-                    !!passportMetadata?.stark_key &&
-                    !!passportMetadata?.user_admin_key;
-                if (metadataExists) {
-                    return user;
-                }
-                return Promise.reject('user wallet addresses not exist');
-            });
-            if (!updatedUser) {
-                return null;
-            }
-            return this.mapOidcUserToDomainModel(updatedUser);
-        }, PassportErrorType.REFRESH_TOKEN_ERROR);
+}
+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 imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ERC721', imxConfig, {
+        token_id: token.tokenId,
+        token_address: token.tokenAddress,
+    });
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
+    }
+    else {
+        return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, imxConfig);
     }
 }
+async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const tokenAddress = token.tokenAddress;
+    const tokenId = token.tokenId;
+    const imxConfig = config.immutableXConfig;
+    const mintsApi = new MintsApi(imxConfig.apiConfiguration);
+    return await mintsApi
+        .getMintableTokenDetailsByClientTokenId({
+        tokenAddress,
+        tokenId,
+    })
+        .then((mintableToken) => completeMintableERC721Withdrawal(ethSigner, starkPublicKey, {
+        type: 'ERC721',
+        data: {
+            id: tokenId,
+            tokenAddress: tokenAddress,
+            blueprint: mintableToken.data.blueprint,
+        },
+    }, config))
+        .catch((error) => {
+        if (error.response?.status === 404) {
+            // token is already minted on L1
+            return completeERC721Withdrawal(ethSigner, starkPublicKey, token, config);
+        }
+        throw error; // unable to recover from any other kind of error
+    });
+}
 
-class MagicAdapter {
-    magicClient;
-    config;
-    constructor(config) {
-        this.config = config;
-        this.magicClient = new Magic(config.magicPublishableApiKey, {
-            network: config.network,
-            extensions: [new OpenIdExtension()],
-        });
+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 imxConfig = config.immutableXConfig;
+    const assetType = await getEncodeAssetInfo('asset', 'ETH', imxConfig);
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
-    async login(idToken) {
-        return withPassportError(async () => {
-            await this.magicClient.openid.loginWithOIDC({
-                jwt: idToken,
-                providerId: this.config.magicProviderId,
-            });
-            return new ethers.providers.Web3Provider(this.magicClient
-                .rpcProvider);
-        }, PassportErrorType.WALLET_CONNECTION_ERROR);
+    else {
+        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
 }
 
-var ReceiveMessage;
-(function (ReceiveMessage) {
-    ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
-    ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
-    ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
-})(ReceiveMessage || (ReceiveMessage = {}));
-var SendMessage;
-(function (SendMessage) {
-    SendMessage["TRANSACTION_START"] = "transaction_start";
-})(SendMessage || (SendMessage = {}));
-var TransactionTypes;
-(function (TransactionTypes) {
-    TransactionTypes["CancelOrder"] = "delete:v1/orders";
-    TransactionTypes["CreateOrder"] = "post:v1/orders";
-    TransactionTypes["CreateTrade"] = "post:v1/trades";
-    TransactionTypes["CreateTransfer"] = "post:v1/transfers";
-    TransactionTypes["CreateBatchTransfer"] = "post:v2/transfers";
-})(TransactionTypes || (TransactionTypes = {}));
-const PassportEventType = 'imx_passport_confirmation';
-
-const openPopupCenter = ({ url, title, width, height, }) => {
-    // Fixes dual-screen position                             Most browsers      Firefox
-    const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : window.screenX;
-    const dualScreenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;
-    const windowWidth = window.innerWidth
-        ? window.innerWidth
-        : document.documentElement.clientWidth
-            ? document.documentElement.clientWidth
-            : screen.width;
-    const windowHeight = window.innerHeight
-        ? window.innerHeight
-        : document.documentElement.clientHeight
-            ? document.documentElement.clientHeight
-            : screen.height;
-    const systemZoom = windowWidth / window.screen.availWidth;
-    const left = (windowWidth - width) / 2 / systemZoom + dualScreenLeft;
-    const top = (windowHeight - height) / 2 / systemZoom + dualScreenTop;
-    const newWindow = window.open(url, title, `
-      scrollbars=yes,
-      width=${width / systemZoom}, 
-      height=${height / systemZoom}, 
-      top=${top}, 
-      left=${left}
-     `);
-    if (!newWindow) {
-        throw new Error('Failed to open confirmation screen');
+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,
+            });
     }
-    newWindow.focus();
-    return newWindow;
-};
+}
 
-const ConfirmationWindowTitle = 'Confirm this transaction';
-const ConfirmationWindowHeight = 600;
-const ConfirmationWindowWidth = 600;
-const ConfirmationWindowClosedPollingDuration = 1000;
-class ConfirmationScreen {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    postMessage(destinationWindow, accessToken, message) {
-        destinationWindow.postMessage({
-            eventType: PassportEventType,
-            accessToken,
-            ...message,
-        }, this.config.passportDomain);
+async function createTrade({ signers: { ethSigner, starkSigner }, 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 starkSigner.signMessage(payloadHash);
+    const createTradeResponse = await tradesApi.createTrade({
+        createTradeRequest: {
+            amount_buy: signableResult.data.amount_buy,
+            amount_sell: signableResult.data.amount_sell,
+            asset_id_buy: signableResult.data.asset_id_buy,
+            asset_id_sell: signableResult.data.asset_id_sell,
+            expiration_timestamp: signableResult.data.expiration_timestamp,
+            fee_info: signableResult.data.fee_info,
+            fees: request.fees,
+            include_fees: true,
+            nonce: signableResult.data.nonce,
+            order_id: request.order_id,
+            stark_key: signableResult.data.stark_key,
+            vault_id_buy: signableResult.data.vault_id_buy,
+            vault_id_sell: signableResult.data.vault_id_sell,
+            stark_signature: starkSignature,
+        },
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return createTradeResponse.data;
+}
+
+async function depositEth({ signers: { ethSigner }, deposit, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const user = await ethSigner.getAddress();
+    const data = {
+        decimals: 18,
+    };
+    const amount = parseUnits(deposit.amount, 'wei');
+    const imxConfig = config.immutableXConfig;
+    const depositsApi = new DepositsApi(imxConfig.apiConfiguration);
+    const encodingApi = new EncodingApi(imxConfig.apiConfiguration);
+    const usersApi = new UsersApi(imxConfig.apiConfiguration);
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
+        },
+        amount: amount.toString(),
+    };
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
+    });
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
+        encodeAssetRequest: {
+            token: {
+                type: deposit.type,
+            },
+        },
+    });
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    if (!isRegistered) {
+        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig, usersApi);
     }
-    startTransaction(accessToken, transaction) {
-        return new Promise((resolve, reject) => {
-            const messageHandler = ({ data, origin }) => {
-                if (origin != this.config.passportDomain ||
-                    data.eventType != PassportEventType) {
-                    return;
-                }
-                switch (data.messageType) {
-                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
-                        this.postMessage(confirmationWindow, accessToken, {
-                            messageType: SendMessage.TRANSACTION_START,
-                            messageData: transaction,
-                        });
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
-                        resolve({ confirmed: true });
-                        break;
-                    }
-                    case ReceiveMessage.TRANSACTION_ERROR: {
-                        reject(new Error('Transaction error'));
-                        break;
-                    }
-                    default:
-                        reject(new Error('Unsupported message type'));
-                }
-            };
-            window.addEventListener('message', messageHandler);
-            const confirmationWindow = openPopupCenter({
-                url: `${this.config.passportDomain}/transaction-confirmation`,
-                title: ConfirmationWindowTitle,
-                width: ConfirmationWindowWidth,
-                height: ConfirmationWindowHeight,
-            });
-            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
-            const timer = setInterval(function () {
-                if (confirmationWindow.closed) {
-                    clearInterval(timer);
-                    window.removeEventListener('message', messageHandler);
-                    resolve({ confirmed: false });
-                }
-            }, ConfirmationWindowClosedPollingDuration);
-        });
+    else {
+        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, imxConfig);
     }
 }
+async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
+    const etherKey = await ethSigner.getAddress();
+    const coreContract = 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 });
+}
 
-const ERC721$1 = 'ERC721';
-const transfer = ({ request, transfersApi, starkSigner, user, passportConfig, }) => {
-    return withPassportError(async () => {
-        const transferAmount = request.type === ERC721$1 ? '1' : request.amount;
-        const getSignableTransferRequest = {
-            sender: user.etherKey,
-            token: convertToSignableToken(request),
-            amount: transferAmount,
-            receiver: request.receiver,
-        };
-        const signableResult = await transfersApi.getSignableTransferV1({
-            getSignableTransferRequest,
-        });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateTransfer,
-            transactionData: getSignableTransferRequest,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const signableResultData = signableResult.data;
-        const { payload_hash: payloadHash } = signableResultData;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const senderStarkKey = await starkSigner.getAddress();
-        const transferSigningParams = {
-            sender_stark_key: signableResultData.sender_stark_key || senderStarkKey,
-            sender_vault_id: signableResultData.sender_vault_id,
-            receiver_stark_key: signableResultData.receiver_stark_key,
-            receiver_vault_id: signableResultData.receiver_vault_id,
-            asset_id: signableResultData.asset_id,
-            amount: signableResultData.amount,
-            nonce: signableResultData.nonce,
-            expiration_timestamp: signableResultData.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        const createTransferRequest = {
-            createTransferRequest: transferSigningParams,
-        };
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const { data: responseData } = await transfersApi.createTransferV1(createTransferRequest, { headers });
-        return {
-            sent_signature: responseData.sent_signature,
-            status: responseData.status?.toString(),
-            time: responseData.time,
-            transfer_id: responseData.transfer_id,
-        };
-    }, PassportErrorType.TRANSFER_ERROR);
-};
-async function batchNftTransfer({ user, starkSigner, request, transfersApi, passportConfig, }) {
-    return withPassportError(async () => {
-        const ethAddress = user.etherKey;
-        const signableRequests = request.map((nftTransfer) => {
-            return {
-                amount: '1',
-                token: convertToSignableToken({
-                    type: ERC721$1,
-                    tokenId: nftTransfer.tokenId,
-                    tokenAddress: nftTransfer.tokenAddress,
-                }),
-                receiver: nftTransfer.receiver,
-            };
-        });
-        const getSignableTransferRequestV2 = {
-            sender_ether_key: ethAddress,
-            signable_requests: signableRequests,
-        };
-        const signableResult = await transfersApi.getSignableTransfer({
-            getSignableTransferRequestV2,
-        });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateBatchTransfer,
-            transactionData: getSignableTransferRequestV2,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
-            const starkSignature = await starkSigner.signMessage(resp.payload_hash);
-            return {
-                sender_vault_id: resp.sender_vault_id,
-                receiver_stark_key: resp.receiver_stark_key,
-                receiver_vault_id: resp.receiver_vault_id,
-                asset_id: resp.asset_id,
-                amount: resp.amount,
-                nonce: resp.nonce,
-                expiration_timestamp: resp.expiration_timestamp,
-                stark_signature: starkSignature,
-            };
-        }));
-        const transferSigningParams = {
-            sender_stark_key: signableResult.data.sender_stark_key,
-            requests,
-        };
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const response = await transfersApi.createTransfer({
-            createTransferRequestV2: transferSigningParams,
-        }, { headers });
-        return {
-            transfer_ids: response?.data.transfer_ids,
-        };
-    }, PassportErrorType.TRANSFER_ERROR);
+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);
 }
 
-const ERC721 = 'ERC721';
-async function createOrder({ starkSigner, user, request, ordersApi, passportConfig, }) {
-    return withPassportError(async () => {
-        const ethAddress = user.etherKey;
-        const amountSell = request.sell.type === ERC721 ? '1' : request.sell.amount;
-        const amountBuy = request.buy.type === ERC721 ? '1' : request.buy.amount;
-        const getSignableOrderRequestV3 = {
-            user: ethAddress,
-            amount_buy: amountBuy,
-            token_buy: convertToSignableToken(request.buy),
-            amount_sell: amountSell,
-            token_sell: convertToSignableToken(request.sell),
-            fees: request.fees,
-            expiration_timestamp: request.expiration_timestamp,
-        };
-        const getSignableOrderResponse = await ordersApi.getSignableOrder({
-            getSignableOrderRequestV3,
-        });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateOrder,
-            transactionData: getSignableOrderRequestV3,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const { payload_hash: payloadHash } = getSignableOrderResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const signableResultData = getSignableOrderResponse.data;
-        const orderParams = {
-            createOrderRequest: {
-                include_fees: true,
-                fees: request.fees,
-                stark_signature: starkSignature,
-                amount_buy: signableResultData.amount_buy,
-                amount_sell: signableResultData.amount_sell,
-                asset_id_buy: signableResultData.asset_id_buy,
-                asset_id_sell: signableResultData.asset_id_sell,
-                expiration_timestamp: signableResultData.expiration_timestamp,
-                nonce: signableResultData.nonce,
-                stark_key: signableResultData.stark_key,
-                vault_id_buy: signableResultData.vault_id_buy,
-                vault_id_sell: signableResultData.vault_id_sell,
+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 headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const createOrderResponse = await ordersApi.createOrder(orderParams, {
-            headers,
-        });
-        return {
-            ...createOrderResponse.data,
-        };
-    }, PassportErrorType.CREATE_ORDER_ERROR);
+        },
+    });
+    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 cancelOrder({ user, starkSigner, request, ordersApi, passportConfig, }) {
-    return withPassportError(async () => {
-        const getSignableCancelOrderRequest = {
-            order_id: request.order_id,
-        };
-        const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
-            getSignableCancelOrderRequest,
-        });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CancelOrder,
-            transactionData: getSignableCancelOrderRequest,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const cancelOrderResponse = await ordersApi.cancelOrder({
-            id: request.order_id.toString(),
-            cancelOrderRequest: {
-                order_id: request.order_id,
-                stark_signature: starkSignature,
-            },
-        }, { headers });
-        return {
-            order_id: cancelOrderResponse.data.order_id,
-            status: cancelOrderResponse.data.status,
-        };
-    }, PassportErrorType.CANCEL_ORDER_ERROR);
+async function 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 exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
-    return withPassportError(async () => {
-        const ethAddress = user.etherKey;
-        const transferAmount = request.amount;
-        const signableResult = await exchangesApi.getExchangeSignableTransfer({
-            id: request.transactionID,
-            getSignableTransferRequest: {
-                sender: ethAddress,
-                token: convertToSignableToken(request),
-                amount: transferAmount,
-                receiver: request.receiver,
-            },
-        });
-        const starkAddress = await starkSigner.getAddress();
-        const { payload_hash: payloadHash } = signableResult.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const transferSigningParams = {
-            sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
-            sender_vault_id: signableResult.data.sender_vault_id,
-            receiver_stark_key: signableResult.data.receiver_stark_key,
-            receiver_vault_id: signableResult.data.receiver_vault_id,
-            asset_id: signableResult.data.asset_id,
-            amount: signableResult.data.amount,
-            nonce: signableResult.data.nonce,
-            expiration_timestamp: signableResult.data.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const response = await exchangesApi.createExchangeTransfer({
-            id: request.transactionID,
-            createTransferRequest: transferSigningParams,
-        }, { headers });
-        return {
-            sent_signature: response?.data.sent_signature,
-            status: response?.data.status?.toString(),
-            time: response?.data.time,
-            transfer_id: response?.data.transfer_id,
-        };
-    }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
+async function 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 createTrade({ request, tradesApi, user, starkSigner, passportConfig, }) {
-    return withPassportError(async () => {
-        const ethAddress = user.etherKey;
-        const getSignableTradeRequest = {
-            expiration_timestamp: request.expiration_timestamp,
-            fees: request.fees,
-            order_id: request.order_id,
-            user: ethAddress,
-        };
-        const getSignableTradeResponse = await tradesApi.getSignableTrade({
-            getSignableTradeRequest,
-        });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateTrade,
-            transactionData: getSignableTradeRequest,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const { payload_hash: payloadHash } = getSignableTradeResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const { data: signableResultData } = getSignableTradeResponse;
-        const tradeParams = {
-            createTradeRequest: {
-                include_fees: true,
-                fees: request?.fees,
-                stark_signature: starkSignature,
-                order_id: request?.order_id,
-                fee_info: signableResultData.fee_info,
-                amount_buy: signableResultData.amount_buy,
-                amount_sell: signableResultData.amount_sell,
-                asset_id_buy: signableResultData.asset_id_buy,
-                asset_id_sell: signableResultData.asset_id_sell,
-                expiration_timestamp: signableResultData.expiration_timestamp,
-                nonce: signableResultData.nonce,
-                stark_key: signableResultData.stark_key,
-                vault_id_buy: signableResultData.vault_id_buy,
-                vault_id_sell: signableResultData.vault_id_sell,
-            },
-        };
-        const headers = { Authorization: 'Bearer ' + user.accessToken };
-        const { data: createTradeResponse } = await tradesApi.createTrade(tradeParams, {
-            headers,
-        });
-        return createTradeResponse;
-    }, PassportErrorType.CREATE_TRADE_ERROR);
+async function exchangeTransfer({ 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.starkSigner.signMessage(payloadHash);
+    const transferSigningParams = {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        sender_stark_key: signableResult.data.sender_stark_key,
+        sender_vault_id: signableResult.data.sender_vault_id,
+        receiver_stark_key: signableResult.data.receiver_stark_key,
+        receiver_vault_id: signableResult.data.receiver_vault_id,
+        asset_id: signableResult.data.asset_id,
+        amount: signableResult.data.amount,
+        nonce: signableResult.data.nonce,
+        expiration_timestamp: signableResult.data.expiration_timestamp,
+        stark_signature: starkSignature,
+    };
+    const response = await exchangeApi.createExchangeTransfer({
+        id: request.transactionID,
+        createTransferRequest: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        sent_signature: response?.data.sent_signature,
+        status: response?.data.status?.toString(),
+        time: response?.data.time,
+        transfer_id: response?.data.transfer_id,
+    };
 }
 
-class PassportImxProvider {
-    user;
-    starkSigner;
-    transfersApi;
-    ordersApi;
-    passportConfig;
-    exchangesApi;
-    tradesApi;
-    constructor({ user, starkSigner, passportConfig }) {
-        this.user = user;
-        this.starkSigner = starkSigner;
-        this.passportConfig = passportConfig;
-        const apiConfig = new Configuration$1({
-            basePath: passportConfig.imxAPIConfiguration.basePath,
-        });
-        this.transfersApi = new TransfersApi(apiConfig);
-        this.ordersApi = new OrdersApi(apiConfig);
-        this.exchangesApi = new ExchangesApi(apiConfig);
-        this.tradesApi = new TradesApi(apiConfig);
+class GenericIMXProvider {
+    config;
+    signers;
+    constructor(config, ethSigner, starkSigner) {
+        this.config = config;
+        this.signers = { ethSigner, starkSigner };
     }
-    async transfer(request) {
-        return transfer({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
-            passportConfig: this.passportConfig,
-        });
+    async getAddress() {
+        return await this.signers.ethSigner.getAddress();
     }
     registerOffchain() {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+        return registerOffchain(this.signers, this.config);
     }
-    isRegisteredOnchain() {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    batchNftTransfer(request) {
+        return batchTransfer({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
-    createOrder(request) {
-        return createOrder({
+    cancelOrder(request) {
+        return cancelOrder({
+            signers: this.signers,
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
-            passportConfig: this.passportConfig,
+            config: this.config,
+        });
+    }
+    completeWithdrawal(starkPublicKey, token) {
+        return completeWithdrawal({
+            config: this.config,
+            signers: this.signers,
+            token,
+            starkPublicKey,
         });
     }
-    cancelOrder(request) {
-        return cancelOrder({
+    createOrder(request) {
+        return createOrder({
+            signers: this.signers,
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
-            passportConfig: this.passportConfig,
+            config: this.config,
         });
     }
     createTrade(request) {
         return createTrade({
+            signers: this.signers,
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            tradesApi: this.tradesApi,
-            passportConfig: this.passportConfig,
+            config: this.config,
         });
     }
-    batchNftTransfer(request) {
-        return batchNftTransfer({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
-            passportConfig: this.passportConfig,
+    deposit(tokenAmount) {
+        return deposit({
+            signers: this.signers,
+            deposit: tokenAmount,
+            config: this.config,
         });
     }
     exchangeTransfer(request) {
         return exchangeTransfer({
+            signers: this.signers,
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            exchangesApi: this.exchangesApi,
+            config: this.config,
         });
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    deposit(deposit) {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    async isRegisteredOnchain() {
+        const starkPublicKey = await this.signers.starkSigner.getAddress();
+        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     prepareWithdrawal(request) {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
-    }
-    completeWithdrawal(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    starkPublicKey, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    token) {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+        return prepareWithdrawal({
+            signers: this.signers,
+            withdrawal: request,
+            config: this.config,
+        });
     }
-    getAddress() {
-        return Promise.resolve(this.starkSigner.getAddress());
+    transfer(request) {
+        return transfer({
+            signers: this.signers,
+            request,
+            config: this.config,
+        });
     }
 }
 
-var Networks;
-(function (Networks) {
-    Networks["PRODUCTION"] = "mainnet";
-    Networks["SANDBOX"] = "goerli";
-})(Networks || (Networks = {}));
+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 Config = {
-    PRODUCTION: {
-        network: Networks.PRODUCTION,
-        authenticationDomain: 'https://auth.immutable.com',
-        magicPublishableApiKey: 'pk_live_10F423798A540ED7',
-        magicProviderId: 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=',
-        baseIMXApiPath: 'https://api.x.immutable.com',
-        passportDomain: 'https://passport.immutable.com',
-    },
-    SANDBOX: {
-        network: Networks.SANDBOX,
-        authenticationDomain: 'https://auth.immutable.com',
-        magicPublishableApiKey: 'pk_live_10F423798A540ED7',
-        magicProviderId: 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=',
-        baseIMXApiPath: 'https://api.sandbox.x.immutable.com',
-        passportDomain: 'https://passport.sandbox.immutable.com',
-    },
+const ERRORS = {
+    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
 };
-const validateConfiguration = (configurationName, configuration, requiredKeys) => {
-    if (!configuration) {
-        throw new PassportError(`${configurationName} cannot be null`, PassportErrorType.INVALID_CONFIGURATION);
+async function connect$1({ chainID, }) {
+    const provider = (await detectEthereumProvider());
+    if (!isRequestableProvider(provider)) {
+        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
     }
-    const missingKeys = requiredKeys
-        .map((key) => !configuration[key] && key)
-        .filter((n) => n)
-        .join(', ');
-    if (missingKeys !== '') {
-        throw new PassportError(`${configurationName} - ${missingKeys} cannot be null`, PassportErrorType.INVALID_CONFIGURATION);
+    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);
     }
-};
-const getPassportConfiguration = (environmentConfiguration, oidcConfiguration) => {
-    validateConfiguration('EnvironmentConfiguration', environmentConfiguration, [
-        'network',
-        'authenticationDomain',
-        'magicPublishableApiKey',
-        'magicProviderId',
-        'passportDomain',
-    ]);
-    validateConfiguration('OidcConfiguration', oidcConfiguration, [
-        'clientId',
-        'logoutRedirectUri',
-        'redirectUri',
-    ]);
-    return {
-        network: environmentConfiguration.network,
-        oidcConfiguration: {
-            authenticationDomain: environmentConfiguration.authenticationDomain,
-            clientId: oidcConfiguration.clientId,
-            logoutRedirectUri: oidcConfiguration.logoutRedirectUri,
-            redirectUri: oidcConfiguration.redirectUri,
-            scope: oidcConfiguration.scope,
-            audience: oidcConfiguration.audience,
-        },
-        imxAPIConfiguration: {
-            basePath: environmentConfiguration.baseIMXApiPath,
-        },
-        passportDomain: environmentConfiguration.passportDomain,
-        magicPublishableApiKey: environmentConfiguration.magicPublishableApiKey,
-        magicProviderId: environmentConfiguration.magicProviderId,
-    };
-};
+}
 
-const getStarkSigner = async (signer) => {
-    return withPassportError(async () => {
-        const privateKey = await generateLegacyStarkPrivateKey(signer);
-        return createStarkSigner(privateKey);
-    }, PassportErrorType.WALLET_CONNECTION_ERROR);
+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);
+}
 
-async function registerPassport({ ethSigner, starkSigner, usersApi }, authorization) {
-    return withPassportError(async () => {
-        const userAddress = await ethSigner.getAddress();
-        const starkPublicKey = await starkSigner.getAddress();
-        const signableResult = await usersApi.getSignableRegistrationOffchain({
-            getSignableRegistrationRequest: {
-                ether_key: userAddress,
-                stark_key: starkPublicKey,
-            },
+const 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 },
         });
-        const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-        const ethSignature = await signRaw(signableMessage, ethSigner);
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const response = await usersApi.registerPassportUser({
-            authorization: `Bearer ` + authorization,
-            registerPassportUserRequest: {
-                eth_signature: ethSignature,
-                ether_key: userAddress,
-                stark_signature: starkSignature,
-                stark_key: starkPublicKey,
-            },
+    });
+}
+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() },
         });
-        return response.statusText;
-    }, PassportErrorType.USER_REGISTRATION_ERROR);
+    });
 }
 
-class Passport {
-    authManager;
-    magicAdapter;
-    config;
-    constructor(environmentConfiguration, oidcConfiguration) {
-        const passportConfiguration = getPassportConfiguration(environmentConfiguration, oidcConfiguration);
-        this.config = passportConfiguration;
-        this.authManager = new AuthManager(this.config);
-        this.magicAdapter = new MagicAdapter(this.config);
+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;
     }
-    async connectImx() {
-        const user = await this.authManager.login();
-        if (!user.idToken) {
-            throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
-        }
-        const provider = await this.magicAdapter.login(user.idToken);
-        const ethSigner = provider.getSigner();
-        const starkSigner = await getStarkSigner(ethSigner);
-        if (!user.etherKey) {
-            const updatedUser = await this.registerUser(ethSigner, starkSigner, user.accessToken);
-            return new PassportImxProvider({
-                user: updatedUser,
-                starkSigner,
-                passportConfig: this.config,
-            });
-        }
-        const userWithEtherKey = user;
-        return new PassportImxProvider({
-            user: userWithEtherKey,
-            starkSigner,
-            passportConfig: this.config,
-        });
+}
+const withProviderError = async (fn, customError) => {
+    try {
+        return await fn();
     }
-    async loginCallback() {
-        return this.authManager.loginCallback();
+    catch (error) {
+        const errorMessage = customError.message || `${error.message}` || 'UnknownError';
+        throw new ProviderError(errorMessage, customError.type);
     }
-    async logout() {
-        return this.authManager.logout();
+};
+
+class MetaMaskIMXProvider extends GenericIMXProvider {
+    static imxSigner;
+    constructor(config, ethSigner, starkSigner) {
+        super(config, ethSigner, starkSigner);
     }
-    async getUserInfo() {
-        const user = await this.authManager.getUser();
-        return user.profile;
+    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 });
     }
-    async getIdToken() {
-        const user = await this.authManager.getUser();
-        return user.idToken;
+    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 });
     }
-    async getAccessToken() {
-        const user = await this.authManager.getUser();
-        return user.accessToken;
+    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 });
     }
-    async registerUser(userAdminKeySigner, starkSigner, jwt) {
-        const configuration = new Configuration$1({
-            basePath: this.config.imxAPIConfiguration.basePath,
-        });
-        const usersApi = new UsersApi(configuration);
-        await registerPassport({
-            ethSigner: userAdminKeySigner,
-            starkSigner,
-            usersApi,
-        }, jwt);
-        const updatedUser = await this.authManager.requestRefreshTokenAfterRegistration();
-        if (!updatedUser) {
-            throw new PassportError('Failed to get refresh token', PassportErrorType.REFRESH_TOKEN_ERROR);
+}
+
+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;
+                }
+            }
         }
-        return updatedUser;
     }
 }
 
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+
 const $762782b6c862d954$export$db5daa1b5156ccfe = [
     {
         constant: true,
@@ -2101,8 +2632,18 @@ const $a47e48dd2c04791b$export$f61f4aaec62f6be9 = {
         ]
     }
 };
+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 = {}));
 
 
 
@@ -2113,70 +2654,177 @@ const $4f91c5f280efe242$export$a130407f3423b97d = {
     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;
+/**
+ * The different types of errors that can be returned by the checkout process.
+ */ 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){
+    constructor(message, type, data){
         super(message);
+        this.message = message;
         this.type = type;
+        this.data = data;
     }
 }
+let $a8bc256d81a5e2c1$export$a22d4e0719ee6def;
+(function(CheckoutInternalErrorType) {
+    CheckoutInternalErrorType["REJECTED_SWITCH_AFTER_ADDING_NETWORK"] = "REJECTED_SWITCH_AFTER_ADDING_NETWORK";
+})($a8bc256d81a5e2c1$export$a22d4e0719ee6def || ($a8bc256d81a5e2c1$export$a22d4e0719ee6def = {}));
 const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
     try {
         return await fn();
     } catch (error) {
-        const errorMessage = customError.message || `${error.message}` || "UnknownError";
-        throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type);
+        const cause = `${error.message}` || "UnknownError";
+        const errorMessage = customError.message ? `[${customError.type}]:${customError.message}. Cause:${cause}` : `[${customError.type}] Cause:${cause}`;
+        if (error instanceof $a8bc256d81a5e2c1$export$b722478a3cbfa3bc) throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
+            ...customError.data,
+            innerErrorType: error.type,
+            ...error.data
+        });
+        throw new $a8bc256d81a5e2c1$export$b722478a3cbfa3bc(errorMessage, customError.type, {
+            ...customError.data
+        });
     }
 };
 
 
 
 
+/* eslint-disable @typescript-eslint/no-explicit-any */ 
 
+/* eslint-disable @typescript-eslint/no-explicit-any */ 
 
 
-async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider) {
-    const network = await provider.getNetwork();
-    if (!Object.values(($a47e48dd2c04791b$export$c06e1e7429de6283)).includes(network.chainId)) // return empty details
-    return {};
-    const chainIdNetworkInfo = ($a47e48dd2c04791b$export$f61f4aaec62f6be9)[network.chainId];
-    const networkInfo = {
-        name: chainIdNetworkInfo.chainName,
-        chainId: parseInt(chainIdNetworkInfo.chainIdHex, 16),
-        nativeCurrency: chainIdNetworkInfo.nativeCurrency
+
+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] ?? ""
     };
-    return networkInfo;
 }
-async function $de192de6ef100f9f$export$b827d9418aeb5dbd(provider, chainId) {
-    if (!Object.values(($a47e48dd2c04791b$export$c06e1e7429de6283)).includes(chainId)) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`${chainId} is not a supported chain`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CHAIN_NOT_SUPPORTED_ERROR);
-    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("provider object is missing request function", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR);
+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 $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(providerPreference, provider, chainId) {
+    let currentProvider = provider;
+    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 (!currentProvider || !currentProvider.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);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await $de192de6ef100f9f$var$switchNetworkInWallet(currentProvider, chainId);
     } catch (err) {
-        if (err.message.includes("Unrecognized chain ID")) try {
-            await $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (err.code === $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE) try {
+            await $de192de6ef100f9f$var$addNetworkToWallet(currentProvider, chainId);
         } catch (err) {
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("user cancelled the add 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 the switch 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);
     }
+    currentProvider = await ($c99672cf2294e839$export$fba2f6c3656e07c1)({
+        providerPreference: providerPreference
+    });
+    if ((await currentProvider.getNetwork()).chainId !== chainId) // user didn't actually switch
+    throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", ($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];
@@ -2185,7 +2833,28 @@ async function $de192de6ef100f9f$export$b827d9418aeb5dbd(provider, chainId) {
             name: newNetwork.chainName,
             chainId: parseInt(newNetwork.chainIdHex, 16),
             nativeCurrency: newNetwork.nativeCurrency
-        }
+        },
+        provider: currentProvider
+    };
+}
+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.
@@ -2222,67 +2891,24 @@ async function $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId) {
 
 
 
-let $efe60cea83bfc4e8$export$f04a61298a47a40f;
-(function(Icon) {
-    Icon["ETH"] = "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";
-    Icon["MATIC"] = "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";
-    Icon["IMX"] = "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";
-})($efe60cea83bfc4e8$export$f04a61298a47a40f || ($efe60cea83bfc4e8$export$f04a61298a47a40f = {}));
-const $efe60cea83bfc4e8$export$3dbcce43073f40c7 = [
-    {
-        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"
-    },
-    {
-        name: "Matic",
-        symbol: "MATIC",
-        address: "0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0",
-        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"
-    },
-    {
-        name: "Immutable X",
-        symbol: "IMX",
-        address: "0xF57e7e7C23978C3cAEC3C3548E3D615c346e79fF",
-        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"
-    }
-];
-const $efe60cea83bfc4e8$var$goerliTokensList = [
-    {
-        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"
-    },
-    {
-        name: "Immutable X",
-        symbol: "IMX",
-        address: "0x1facdd0165489f373255a90304650e15481b2c85",
-        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"
-    }
-];
-const $efe60cea83bfc4e8$var$polygonTokensList = [];
-const $efe60cea83bfc4e8$export$473cec51305fdae8 = (chainId)=>{
-    let tokenList = [];
-    switch(chainId){
-        case ($a47e48dd2c04791b$export$c06e1e7429de6283).ETHEREUM:
-            tokenList = $efe60cea83bfc4e8$export$3dbcce43073f40c7;
-            break;
-        case ($a47e48dd2c04791b$export$c06e1e7429de6283).GOERLI:
-            tokenList = $efe60cea83bfc4e8$var$goerliTokensList;
-            break;
-        case ($a47e48dd2c04791b$export$c06e1e7429de6283).POLYGON:
-            tokenList = $efe60cea83bfc4e8$var$polygonTokensList;
-            break;
-        default:
-            tokenList = $efe60cea83bfc4e8$export$3dbcce43073f40c7;
-    }
+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: tokenList
+        tokens: filteredTokenList
     };
 };
 
@@ -2292,6 +2918,9 @@ const $efe60cea83bfc4e8$export$473cec51305fdae8 = (chainId)=>{
 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,
@@ -2327,7 +2956,10 @@ async function $1564e43dde50bb61$export$60e0fe116a0e6ed0(provider, walletAddress
 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 = ($efe60cea83bfc4e8$export$473cec51305fdae8)(chainId);
+    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 ?? "")));
@@ -2342,57 +2974,29 @@ const $1564e43dde50bb61$export$fee49741664a4d7e = async (provider, walletAddress
 
 
 
-/* eslint-disable @typescript-eslint/no-explicit-any */ 
 
 
 
-async function $c99672cf2294e839$export$2d040992269b4717(providerPreference) {
-    const provider = await $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference);
-    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR);
-    const accounts = await provider.provider.request({
-        method: ($4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION,
-        params: []
+
+var $6f3c55a615003cbf$exports = {};
+$6f3c55a615003cbf$exports = JSON.parse('[{"connectionProvider":"metamask","icon":"some-icon-url","name":"MetaMask","description":"complete web3 wallet solution","platform":["desktop"]},{"connectionProvider":"passport","icon":"pp-icon","name":"Passport","description":"Web3 with your email!","platform":["mobile","desktop"]},{"connectionProvider":"gamestop","icon":"gme-icon","name":"GameStop","description":"Never stopping the game!","platform":["mobile"]}]');
+
+
+async function $5cdde2ffe6360fec$export$a822caa90d7eef09({ type: type = ($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;
     });
-    // accounts[0] will have the active account if connected.
     return {
-        isConnected: accounts && accounts.length > 0,
-        walletAddress: accounts[0] ?? ""
+        wallets: filteredWalletsList
     };
 }
-async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
-    const web3Provider = await $c99672cf2294e839$var$getWalletProviderForPreference(params.providerPreference);
-    await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        if (!web3Provider || !web3Provider?.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR);
-        // this makes the request to the wallet to connect i.e request eth accounts ('eth_requestAccounts')
-        await web3Provider.provider.request({
-            method: ($4f91c5f280efe242$export$a130407f3423b97d).CONNECT,
-            params: []
-        });
-    }, {
-        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR
-    });
-    return web3Provider;
-}
-async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
-    let web3Provider = null;
-    switch(providerPreference){
-        case ($d176a05e966364ba$export$3bfad4d03ada24c4).METAMASK:
-            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
-            break;
-        default:
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference was not detected", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CONNECT_PROVIDER_ERROR);
-    }
-    return web3Provider;
-}
-async function $c99672cf2294e839$var$getMetaMaskProvider() {
-    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        return await (detectEthereumProvider)();
-    }, {
-        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR
-    });
-    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR);
-    return new (Web3Provider)(provider);
-}
 
 
 
@@ -2414,34 +3018,98 @@ const $dbe95599a4661140$export$8e0e7ffc78696d30 = async (params)=>{
 
 
 
+
 class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
-    async checkIsWalletConnected(params) {
+    /**
+   * Check if a wallet is connected to the current application without requesting permission from the wallet and hence triggering a connect popup.
+   * @param {CheckConnectionParams} params - The necessary data required to verify a wallet connection status.
+   * @returns Wallet connection status details.
+   * @throws {@link ErrorType}
+   */ async checkIsWalletConnected(params) {
         return $c99672cf2294e839$export$2d040992269b4717(params.providerPreference);
     }
-    async connect(params) {
+    /**
+   * Establish a connection with a wallet provider such as MetaMask and returns the provider object and the current network details.
+   * @param {ConnectParams} params - The necessary data required to establish a connection with a wallet provider.
+   * @returns Wallet provider and current network information.
+   * @throws {@link ErrorType}
+   */ async connect(params) {
+        this.providerPreference = params.providerPreference;
         const provider = await $c99672cf2294e839$export$fba2f6c3656e07c1(params);
-        const network = await ($de192de6ef100f9f$export$79f13b4cfaaf0d09)(provider);
+        const networkInfo = await $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider);
         return {
             provider: provider,
-            network: network
+            network: networkInfo
         };
     }
-    async switchNetwork(params) {
-        return await ($de192de6ef100f9f$export$b827d9418aeb5dbd)(params.provider, params.chainId);
-    }
-    async getBalance(params) {
+    /**
+   * Switch the currently connected wallet to a new network.
+   * @param {SwitchNetworkParams} params - The necessary data required to switch network.
+   * @returns The new network information.
+   * @throws {@link ErrorType}
+   */ async switchNetwork(params) {
+        if (!this.providerPreference) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`connect should be called before switchNetwork to set the provider preference`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_PREFERENCE_ERROR);
+        return await $de192de6ef100f9f$export$b827d9418aeb5dbd(this.providerPreference, params.provider, params.chainId);
+    }
+    /**
+   * Fetch the balance of the native token of the current connected network or, if a contract address is provided, it will return the balance of that ERC20 token. For example, if the wallet is connected to the Ethereum Mainnet then the function gets the wallet ETH L1 balance.
+   * @param {GetBalanceParams} params - The necessary data required to fetch the wallet balance.
+   * @returns Native token balance for the given wallet.
+   * @throws {@link ErrorType}
+   */ async getBalance(params) {
         if (!params.contractAddress || params.contractAddress === "") return await $1564e43dde50bb61$export$df96cd8d56be0ab1(params.provider, params.walletAddress);
         return await $1564e43dde50bb61$export$60e0fe116a0e6ed0(params.provider, params.walletAddress, params.contractAddress);
     }
-    async getAllBalances(params) {
+    /**
+   * Fetch all available balances (ERC20 & Native) of the current connected network of the given wallet. It will loop through the list of allowed tokens and check for balance on each one.
+   * @param {GetAllBalancesParams} params - The necessary data required to fetch all the wallet balances.
+   * @returns List of tokens balance for the given wallet.
+   * @throws {@link ErrorType}
+   */ async getAllBalances(params) {
         return $1564e43dde50bb61$export$fee49741664a4d7e(params.provider, params.walletAddress, params.chainId);
     }
-    getTokenAllowList(params) {
-        return $efe60cea83bfc4e8$export$473cec51305fdae8(params.chainId);
-    }
-    async sendTransaction(params) {
+    /**
+   * Fetch the list of available networks that a wallet can add or/and switch to.
+   * @param {GetNetworkAllowListParams} params - The necessary data required to fetch the list of available networks.
+   * @returns List of networks.
+   * @throws {@link ErrorType}
+   */ async getNetworkAllowList(params) {
+        return await $de192de6ef100f9f$export$3043f6442a9ef563(params);
+    }
+    /**
+   * Get the list of tokens which are allowed to be used with the product.
+   * @param {GetTokenAllowListParams} params - The necessary data required to fetch the list of allowed tokens.
+   * @returns List of allowed tokens.
+   * @throws {@link ErrorType}
+   */ async getTokenAllowList(params) {
+        return await $efe60cea83bfc4e8$export$473cec51305fdae8(params);
+    }
+    /**
+   * Fetch the list of wallets which are available to connect with.
+   * @param {GetWalletAllowListParams} params - The necessary data required to fetch the list of allowed wallets.
+   * @returns List of allowed wallets.
+   * @throws {@link ErrorType}
+   */ async getWalletAllowList(params) {
+        return await $5cdde2ffe6360fec$export$a822caa90d7eef09(params);
+    }
+    /**
+   * Send a generic transaction to the provider.
+   * @param {SendTransactionParams} params - The necessary data required to send a transaction.
+   * @returns Transaction response.
+   * @throws {@link ErrorType}
+   * @remarks
+   * Further documenation can be found at [MetaMask | Sending Transactions](https://docs.metamask.io/guide/sending-transactions.html).
+   */ async sendTransaction(params) {
         return await $dbe95599a4661140$export$8e0e7ffc78696d30(params);
     }
+    /**
+   * Get network information about the currently selected network.
+   * @param {GetNetworkParams} params - The necessary data required to get the current network information.
+   * @returns Network details.
+   * @throws {@link ErrorType}
+   */ async getNetworkInfo(params) {
+        return await $de192de6ef100f9f$export$79f13b4cfaaf0d09(params.provider);
+    }
 }
 
 function $parcel$export(e, n, v, s) {
@@ -2467,6 +3135,7 @@ let $d71a87afc3136184$export$e72e7f9969a47dd3;
 (function(ConnectEventType) {
     ConnectEventType["SUCCESS"] = "success";
     ConnectEventType["FAILURE"] = "failure";
+    ConnectEventType["CLOSE_WIDGET"] = "close-widget";
 })($d71a87afc3136184$export$e72e7f9969a47dd3 || ($d71a87afc3136184$export$e72e7f9969a47dd3 = {}));
 
 
@@ -2533,4 +3202,4 @@ let $9234b4c577442a97$export$c88931fdc51854eb;
     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, Config, Configuration, $d71a87afc3136184$export$e72e7f9969a47dd3 as ConnectEventType, $d176a05e966364ba$export$3bfad4d03ada24c4 as ConnectionProviders, Environment, GenericIMXProvider, $88e4c575901cd68c$export$5a0ace85cae72d45 as IMTBLWidgetEvents, MetaMaskIMXProvider, $9234b4c577442a97$export$95be4ae94445245a as Network, PRODUCTION, Passport, PassportError, SANDBOX, StarkExAPIFactory, $5d497088f13bb116$export$140a49745ab55563 as SwapEventType, $9d0f1783d4d36e8a$export$d9be06b70b28c742 as WalletEventType, $9234b4c577442a97$export$c88931fdc51854eb as WidgetTheme };
+export { $28a5fdc2f5e6c742$export$d1bfa21f7c76447a as BridgeEventType, $ede253beebe0de4a$export$90db5fe1be5993c1 as BuyEventType, $a47e48dd2c04791b$export$c06e1e7429de6283 as ChainId, $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 as Checkout, $a8bc256d81a5e2c1$export$e3dc0620abde7f5a as CheckoutErrorType, $d71a87afc3136184$export$e72e7f9969a47dd3 as ConnectEventType, $d176a05e966364ba$export$3bfad4d03ada24c4 as ConnectionProviders, Environment, GenericIMXProvider, $88e4c575901cd68c$export$5a0ace85cae72d45 as IMTBLWidgetEvents, ImmutableConfiguration, ImmutableXClient, MetaMaskIMXProvider, $9234b4c577442a97$export$95be4ae94445245a as Network, $a47e48dd2c04791b$export$1f05a55fe0680cc7 as NetworkFilterTypes, Passport, PassportConfiguration, PassportError, ProviderConfiguration, $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 };