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

package/dist/index.js

@@ -1,13 +1,14 @@
-import { ImmutableX, Config, TransfersApi, OrdersApi, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi, Configuration, 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;
@@ -31,7 +32,7 @@ const PRODUCTION = () => {
         chainID: 1,
         coreContractAddress: '0x5FDCCA53617f4d2b9134B29090C87D01058e27e9',
         registrationContractAddress: '0x72a06bf2a1CE5e39cBA06c0CAb824960B587d64c',
-        sdkVersion: 'ts-immutable-sdk-0.0.1-alpha.3',
+        sdkVersion: 'ts-immutable-sdk-0.1.0-alpha',
     });
 };
 // Set `sdkVersion` on config
@@ -41,10 +42,10 @@ const SANDBOX = () => {
         chainID: 5,
         coreContractAddress: '0x7917eDb51ecD6CdB3F9854c3cc593F33de10c623',
         registrationContractAddress: '0x1C97Ada273C9A52253f463042f29117090Cd7D83',
-        sdkVersion: 'ts-immutable-sdk-0.0.1-alpha.3',
+        sdkVersion: 'ts-immutable-sdk-0.1.0-alpha',
     });
 };
-class StarkExConfiguration {
+class ImxConfiguration {
     immutableXConfig;
     baseConfig;
     constructor({ baseConfig, overrides }) {
@@ -67,11 +68,462 @@ class StarkExConfiguration {
     }
 }
 
-const StarkExAPIFactory = (config) => {
-    const imtblClient = new ImmutableX(config.immutableXConfig);
-    const { deposit, registerOffchain, isRegisteredOnchain, prepareWithdrawal, completeWithdrawal, createOrder, cancelOrder, createTrade, transfer, batchNftTransfer, ...StarkEx } = imtblClient;
-    return { ...StarkEx };
-};
+class ImmutableXClient {
+    immutableX;
+    depositsApi;
+    mintsApi;
+    ordersApi;
+    tokensApi;
+    tradesApi;
+    transfersApi;
+    exchangeApi;
+    nftCheckoutPrimaryApi;
+    usersApi;
+    withdrawalsApi;
+    balanceApi;
+    assetApi;
+    collectionApi;
+    metadataApi;
+    metadataRefreshesApi;
+    projectsApi;
+    constructor(config) {
+        const imxConfig = new ImxConfiguration(config);
+        this.immutableX = new ImmutableX(imxConfig.immutableXConfig);
+        this.depositsApi = this.immutableX.depositsApi;
+        this.mintsApi = this.immutableX.mintsApi;
+        this.ordersApi = this.immutableX.ordersApi;
+        this.tokensApi = this.immutableX.tokensApi;
+        this.tradesApi = this.immutableX.tradesApi;
+        this.transfersApi = this.immutableX.transfersApi;
+        this.exchangeApi = this.immutableX.exchangeApi;
+        this.usersApi = this.immutableX.usersApi;
+        this.withdrawalsApi = this.immutableX.withdrawalsApi;
+        this.balanceApi = this.immutableX.balanceApi;
+        this.assetApi = this.immutableX.assetApi;
+        this.collectionApi = this.immutableX.collectionApi;
+        this.metadataApi = this.immutableX.metadataApi;
+        this.metadataRefreshesApi = this.immutableX.metadataRefreshesApi;
+        this.nftCheckoutPrimaryApi = this.immutableX.nftCheckoutPrimaryApi;
+        this.projectsApi = this.immutableX.projectsApi;
+    }
+    /**
+     * Get details of a Deposit with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Deposit
+     * @throws {@link index.IMXError}
+     */
+    getDeposit(request) {
+        return this.immutableX.getDeposit(request);
+    }
+    /**
+     * Get a list of Deposits
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Deposits
+     * @throws {@link index.IMXError}
+     */
+    listDeposits(request) {
+        return this.immutableX.listDeposits(request);
+    }
+    /**
+     * Get Stark keys for a registered User
+     * @param ethAddress - the eth address of the User
+     * @returns a promise that resolves with the requested User
+     * @throws {@link index.IMXError}
+     */
+    getUser(ethAddress) {
+        return this.immutableX.getUser(ethAddress);
+    }
+    /**
+     * Get details of an Asset
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Asset
+     * @throws {@link index.IMXError}
+     */
+    getAsset(request) {
+        return this.immutableX.getAsset(request);
+    }
+    /**
+     * Get a list of Assets
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Assets
+     * @throws {@link index.IMXError}
+     */
+    listAssets(request) {
+        return this.immutableX.listAssets(request);
+    }
+    /**
+     * Create a Collection
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Collection
+     * @throws {@link index.IMXError}
+     */
+    createCollection(ethSigner, request) {
+        return this.immutableX.createCollection(ethSigner, request);
+    }
+    /**
+     * Get details of a Collection at the given address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Collection
+     * @throws {@link index.IMXError}
+     */
+    getCollection(request) {
+        return this.immutableX.getCollection(request);
+    }
+    /**
+     * Get a list of Collection filters
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collection Filters
+     * @throws {@link index.IMXError}
+     */
+    listCollectionFilters(request) {
+        return this.immutableX.listCollectionFilters(request);
+    }
+    /**
+     * Get a list of Collections
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Collections
+     * @throws {@link index.IMXError}
+     */
+    listCollections(request) {
+        return this.collectionApi.listCollections(request).then((res) => res.data);
+    }
+    /**
+     * Update a Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the updated Collection
+     * @throws {@link index.IMXError}
+     */
+    updateCollection(ethSigner, collectionAddress, request) {
+        return this.immutableX.updateCollection(ethSigner, collectionAddress, request);
+    }
+    /**
+     * Add metadata schema to Collection
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the SuccessResponse if successful
+     * @throws {@link index.IMXError}
+     */
+    addMetadataSchemaToCollection(ethSigner, collectionAddress, request) {
+        return this.immutableX.addMetadataSchemaToCollection(ethSigner, collectionAddress, request);
+    }
+    /**
+     * Get Metadata schema
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Metadata schema
+     * @throws {@link index.IMXError}
+     */
+    getMetadataSchema(request) {
+        return this.immutableX.getMetadataSchema(request);
+    }
+    /**
+     * Update metadata schema by name
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param name - the Metadata schema name
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the SuccessResponse if successful
+     * @throws {@link index.IMXError}
+     */
+    updateMetadataSchemaByName(ethSigner, collectionAddress, name, request) {
+        return this.immutableX.updateMetadataSchemaByName(ethSigner, collectionAddress, name, request);
+    }
+    /**
+     * Get a list of metadata refreshes
+     * @param ethSigner - the L1 signer
+     * @param collectionAddress - the Collection contract address
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refreshes
+     * @throws {@link index.IMXError}
+     */
+    listMetadataRefreshes(ethSigner, collectionAddress, pageSize, cursor) {
+        return this.immutableX.listMetadataRefreshes(ethSigner, collectionAddress, pageSize, cursor);
+    }
+    /**
+     * Get a list of metadata refresh errors
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @returns a promise that resolves with the requested metadata refresh errors
+     * @throws {@link index.IMXError}
+     */
+    getMetadataRefreshErrors(ethSigner, refreshId, pageSize, cursor) {
+        return this.immutableX.getMetadataRefreshErrors(ethSigner, refreshId, pageSize, cursor);
+    }
+    /**
+     * Get a list of metadata refresh results
+     * @param ethSigner - the L1 signer
+     * @param refreshId - the metadata refresh ID
+     * @returns a promise that resolves with the requested metadata refresh results
+     * @throws {@link index.IMXError}
+     */
+    getMetadataRefreshResults(ethSigner, refreshId) {
+        return this.immutableX.getMetadataRefreshResults(ethSigner, refreshId);
+    }
+    /**
+     * Request a metadata refresh
+     * @param ethSigner - the L1 signer
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested metadata refresh
+     * @throws {@link index.IMXError}
+     */
+    createMetadataRefresh(ethSigner, request) {
+        return this.immutableX.createMetadataRefresh(ethSigner, request);
+    }
+    /**
+     * Create a Project
+     * @param ethSigner - the L1 signer
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the created Project
+     * @throws {@link index.IMXError}
+     */
+    async createProject(ethSigner, request) {
+        return this.immutableX.createProject(ethSigner, request);
+    }
+    /**
+     * Get a Project
+     * @param ethSigner - the L1 signer
+     * @param id - the Project ID
+     * @returns a promise that resolves with the requested Project
+     * @throws {@link index.IMXError}
+     */
+    async getProject(ethSigner, id) {
+        return this.immutableX.getProject(ethSigner, id);
+    }
+    /**
+     * Get Projects owned by the given User
+     * @param ethSigner - the L1 signer
+     * @param pageSize - the page size of the result
+     * @param cursor - the cursor
+     * @param orderBy - the property to sort by
+     * @param direction - direction to sort (asc/desc)
+     * @returns a promise that resolves with the requested Projects
+     * @throws {@link index.IMXError}
+     */
+    async getProjects(ethSigner, pageSize, cursor, orderBy, direction) {
+        return this.immutableX.getProjects(ethSigner, pageSize, cursor, orderBy, direction);
+    }
+    /**
+     * Get the token Balances of the User
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Balance
+     * @throws {@link index.IMXError}
+     */
+    getBalance(request) {
+        return this.immutableX.getBalance(request);
+    }
+    /**
+     * Get a list of Balances for given User
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Balances
+     * @throws {@link index.IMXError}
+     */
+    listBalances(request) {
+        return this.immutableX.listBalances(request);
+    }
+    /**
+     * Get details of a Mint with the given ID
+     * @param request the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Mint
+     * @throws {@link index.IMXError}
+     */
+    getMint(request) {
+        return this.immutableX.getMint(request);
+    }
+    /**
+     * Get a list of Mints
+     * @param request optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Mints
+     * @throws {@link index.IMXError}
+     */
+    listMints(request) {
+        return this.immutableX.listMints(request);
+    }
+    /**
+     * Mint tokens in a batch with fees
+     * @param ethSigner - the L1 signer
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the minted tokens
+     * @throws {@link index.IMXError}
+     */
+    mint(ethSigner, request) {
+        return this.immutableX.mint(ethSigner, request);
+    }
+    /**
+     * Get a list of Withdrawals
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Withdrawals
+     * @throws {@link index.IMXError}
+     */
+    listWithdrawals(request) {
+        return this.immutableX.listWithdrawals(request);
+    }
+    /**
+     * Get details of Withdrawal with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Withdrawal
+     * @throws {@link index.IMXError}
+     */
+    getWithdrawal(request) {
+        return this.immutableX.getWithdrawal(request);
+    }
+    /**
+     * Get details of an Order with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Order
+     * @throws {@link index.IMXError}
+     */
+    getOrder(request) {
+        return this.immutableX.getOrder(request);
+    }
+    /**
+     * Get a list of Orders
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Orders
+     * @throws {@link index.IMXError}
+     */
+    listOrders(request) {
+        return this.immutableX.listOrders(request);
+    }
+    /**
+     * Get details of a Trade with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Trade
+     * @throws {@link index.IMXError}
+     */
+    getTrade(request) {
+        return this.immutableX.getTrade(request);
+    }
+    /**
+     * Get a list of Trades
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Trades
+     * @throws {@link index.IMXError}
+     */
+    listTrades(request) {
+        return this.immutableX.listTrades(request);
+    }
+    /**
+     * Get details of a Token
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Token
+     * @throws {@link index.IMXError}
+     */
+    getToken(request) {
+        return this.immutableX.getToken(request);
+    }
+    /**
+     * Get a list of Tokens
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Tokens
+     * @throws {@link index.IMXError}
+     */
+    listTokens(request) {
+        return this.immutableX.listTokens(request);
+    }
+    /**
+     * Get details of a Transfer with the given ID
+     * @param request - the request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested Transfer
+     * @throws {@link index.IMXError}
+     */
+    getTransfer(request) {
+        return this.immutableX.getTransfer(request);
+    }
+    /**
+     * Get a list of Transfers
+     * @param request - optional request object containing the parameters to be provided in the API request
+     * @returns a promise that resolves with the requested list of Transfers
+     * @throws {@link index.IMXError}
+     */
+    listTransfers(request) {
+        return this.immutableX.listTransfers(request);
+    }
+    /**
+     * Create a new Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transaction
+     * @throws {@link index.IMXError}
+     */
+    createExchange(request) {
+        return this.immutableX.createExchange(request).then((res) => res.data);
+    }
+    /**
+     * Get an Exchange transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the Exchange Transaction
+     * @throws {@link index.IMXError}
+     */
+    getExchange(request) {
+        return this.immutableX.getExchange(request).then((res) => res.data);
+    }
+    /**
+     * Get Exchange transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with Exchange Transactions
+     * @throws {@link index.IMXError}
+     */
+    getExchanges(request) {
+        return this.immutableX.getExchanges(request).then((res) => res.data);
+    }
+    /**
+     * Create a new Transfer request
+     * @param walletConnection - the pair of Eth/Stark signers
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created Exchange Transfer
+     * @throws {@link index.IMXError}
+     */
+    exchangeTransfer(walletConnection, request) {
+        return this.immutableX.exchangeTransfer(walletConnection, request);
+    }
+    /**
+     * Create a new nft primary transaction
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with the created nft primary Transaction
+     * @throws {@link index.IMXError}
+     */
+    createNftPrimary(request) {
+        return this.immutableX.createNftPrimary(request).then((res) => res.data);
+    }
+    /**
+     * Get nft primary supported currencies and their limits
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary Currencies
+     * @throws {@link index.IMXError}
+     */
+    getCurrenciesNFTCheckoutPrimary(request) {
+        return this.immutableX
+            .getCurrenciesNFTCheckoutPrimary(request)
+            .then((res) => res.data);
+    }
+    /**
+     * Get nft primary transaction by transaction id
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link index.IMXError}
+     */
+    getNftPrimaryTransaction(request) {
+        return this.immutableX
+            .getNftPrimaryTransaction(request)
+            .then((res) => res.data);
+    }
+    /**
+     * Get list of nft primary transactions
+     * @param request - the request object to be provided in the API request
+     * @returns a promise that resolves with nft primary transaction
+     * @throws {@link index.IMXError}
+     */
+    getNftPrimaryTransactions(request) {
+        return this.immutableX
+            .getNftPrimaryTransactions(request)
+            .then((res) => res.data);
+    }
+}
 
 // used to sign message with L1 keys. Used for registration
 function serializeEthSignature(sig) {
@@ -143,696 +595,880 @@ 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.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 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.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,
+    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.immutableXConfig);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const ordersApi = new OrdersApi(config.immutableXConfig.apiConfiguration);
-    const amountSell = request.sell.type === 'ERC721' ? '1' : request.sell.amount;
-    const amountBuy = request.buy.type === 'ERC721' ? '1' : request.buy.amount;
-    const getSignableOrderRequest = {
-        user: ethAddress,
-        amount_buy: amountBuy,
-        token_buy: convertToSignableToken(request.buy),
-        amount_sell: amountSell,
-        token_sell: convertToSignableToken(request.sell),
-        fees: request.fees,
-        expiration_timestamp: request.expiration_timestamp,
-    };
-    const getSignableOrderResponse = await ordersApi.getSignableOrder({
-        getSignableOrderRequestV3: getSignableOrderRequest,
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableOrderResponse.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
-    const resp = getSignableOrderResponse.data;
-    const orderParams = {
-        createOrderRequest: {
-            amount_buy: resp.amount_buy,
-            amount_sell: resp.amount_sell,
-            asset_id_buy: resp.asset_id_buy,
-            asset_id_sell: resp.asset_id_sell,
-            expiration_timestamp: resp.expiration_timestamp,
-            include_fees: true,
-            fees: request.fees,
-            nonce: resp.nonce,
-            stark_key: resp.stark_key,
-            stark_signature: starkSignature,
-            vault_id_buy: resp.vault_id_buy,
-            vault_id_sell: resp.vault_id_sell,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    };
-    const createOrderResponse = await ordersApi.createOrder(orderParams);
-    return {
-        ...createOrderResponse.data,
-    };
+class MagicAdapter {
+    magicClient;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.magicClient = new Magic(config.magicPublishableApiKey, {
+            network: config.network,
+            extensions: [new OpenIdExtension()],
+        });
+    }
+    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 cancelOrder$1({ signers, request, config, }) {
-    const ordersApi = new OrdersApi(config.immutableXConfig.apiConfiguration);
-    const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
-        getSignableCancelOrderRequest: {
-            order_id: request.order_id,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const cancelOrderResponse = await ordersApi.cancelOrder({
-        id: request.order_id.toString(),
-        cancelOrderRequest: {
-            order_id: request.order_id,
-            stark_signature: starkSignature,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return {
-        order_id: cancelOrderResponse.data.order_id,
-        status: cancelOrderResponse.data.status,
-    };
+
+var ReceiveMessage;
+(function (ReceiveMessage) {
+    ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
+    ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
+    ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
+})(ReceiveMessage || (ReceiveMessage = {}));
+var SendMessage;
+(function (SendMessage) {
+    SendMessage["TRANSACTION_START"] = "transaction_start";
+})(SendMessage || (SendMessage = {}));
+var TransactionTypes;
+(function (TransactionTypes) {
+    TransactionTypes["CancelOrder"] = "delete:v1/orders";
+    TransactionTypes["CreateOrder"] = "post:v1/orders";
+    TransactionTypes["CreateTrade"] = "post:v1/trades";
+    TransactionTypes["CreateTransfer"] = "post:v1/transfers";
+    TransactionTypes["CreateBatchTransfer"] = "post:v2/transfers";
+})(TransactionTypes || (TransactionTypes = {}));
+const PassportEventType = 'imx_passport_confirmation';
+
+const openPopupCenter = ({ url, title, width, height, }) => {
+    const left = Math.max(0, Math.round(window.screenX + (window.outerWidth - width) / 2));
+    const top = Math.max(0, Math.round(window.screenY + (window.outerHeight - height) / 2));
+    const newWindow = window.open(url, title, `
+      scrollbars=yes,
+      width=${width}, 
+      height=${height}, 
+      top=${top}, 
+      left=${left}
+     `);
+    if (!newWindow) {
+        throw new Error('Failed to open confirmation screen');
+    }
+    newWindow.focus();
+    return newWindow;
+};
+
+const ConfirmationWindowTitle = 'Confirm this transaction';
+const ConfirmationWindowHeight = 380;
+const ConfirmationWindowWidth = 480;
+const ConfirmationWindowClosedPollingDuration = 1000;
+class ConfirmationScreen {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    postMessage(destinationWindow, accessToken, message) {
+        destinationWindow.postMessage({
+            eventType: PassportEventType,
+            accessToken,
+            ...message,
+        }, this.config.passportDomain);
+    }
+    startTransaction(accessToken, transaction, popupOptions) {
+        return new Promise((resolve, reject) => {
+            const messageHandler = ({ data, origin }) => {
+                if (origin != this.config.passportDomain ||
+                    data.eventType != PassportEventType) {
+                    return;
+                }
+                switch (data.messageType) {
+                    case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
+                        this.postMessage(confirmationWindow, accessToken, {
+                            messageType: SendMessage.TRANSACTION_START,
+                            messageData: transaction,
+                        });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_CONFIRMED: {
+                        resolve({ confirmed: true });
+                        break;
+                    }
+                    case ReceiveMessage.TRANSACTION_ERROR: {
+                        reject(new Error('Transaction error'));
+                        break;
+                    }
+                    default:
+                        reject(new Error('Unsupported message type'));
+                }
+            };
+            window.addEventListener('message', messageHandler);
+            const confirmationWindow = openPopupCenter({
+                url: `${this.config.passportDomain}/transaction-confirmation`,
+                title: ConfirmationWindowTitle,
+                width: popupOptions?.width || ConfirmationWindowWidth,
+                height: popupOptions?.height || ConfirmationWindowHeight,
+            });
+            // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
+            const timer = setInterval(function () {
+                if (confirmationWindow.closed) {
+                    clearInterval(timer);
+                    window.removeEventListener('message', messageHandler);
+                    resolve({ confirmed: false });
+                }
+            }, ConfirmationWindowClosedPollingDuration);
+        });
+    }
 }
 
-async function registerOffchain(signers, config) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const usersApi = new UsersApi(config.immutableXConfig.apiConfiguration);
-    const userAddress = await signers.ethSigner.getAddress();
-    const starkPublicKey = await signers.starkExSigner.getAddress();
-    const signableResult = await usersApi.getSignableRegistrationOffchain({
-        getSignableRegistrationRequest: {
-            ether_key: userAddress,
-            stark_key: starkPublicKey,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
-    const registeredUser = await usersApi.registerUser({
-        registerUserRequest: {
-            eth_signature: ethSignature,
-            ether_key: userAddress,
+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,
-            stark_key: starkPublicKey,
-        },
-    });
-    return registeredUser.data;
+        };
+        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 isRegisteredOnChain(starkPublicKey, ethSigner, config) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const registrationContract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
-    try {
-        return await registrationContract.isRegistered(starkPublicKey);
-    }
-    catch (ex) {
-        if (ex.reason === 'USER_UNREGISTERED') {
-            return false;
+
+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,
+            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');
         }
-        throw ex;
-    }
+        const { payload_hash: payloadHash } = getSignableOrderResponse.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const signableResultData = getSignableOrderResponse.data;
+        const orderParams = {
+            createOrderRequest: {
+                include_fees: true,
+                fees: request.fees,
+                stark_signature: starkSignature,
+                amount_buy: signableResultData.amount_buy,
+                amount_sell: signableResultData.amount_sell,
+                asset_id_buy: signableResultData.asset_id_buy,
+                asset_id_sell: signableResultData.asset_id_sell,
+                expiration_timestamp: signableResultData.expiration_timestamp,
+                nonce: signableResultData.nonce,
+                stark_key: signableResultData.stark_key,
+                vault_id_buy: signableResultData.vault_id_buy,
+                vault_id_sell: signableResultData.vault_id_sell,
+            },
+        };
+        const headers = {
+            Authorization: 'Bearer ' + user.accessToken,
+        };
+        const createOrderResponse = await ordersApi.createOrder(orderParams, {
+            headers,
+        });
+        return {
+            ...createOrderResponse.data,
+        };
+    }, PassportErrorType.CREATE_ORDER_ERROR);
 }
-async function 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,
-    };
+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);
 }
 
-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),
+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 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,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return prepareWithdrawalResponse.data;
+        };
+        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 getEncodeAssetInfo(assetType, tokenType, config, tokenData) {
-    const encodingApi = new EncodingApi(config.apiConfiguration);
-    const result = await encodingApi.encodeAsset({
-        assetType,
-        encodeAssetRequest: {
-            token: {
-                type: tokenType,
-                ...(tokenData && { data: tokenData }),
+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,
             },
-        },
-    });
-    return result.data;
+        };
+        const headers = { Authorization: 'Bearer ' + user.accessToken };
+        const { data: createTradeResponse } = await tradesApi.createTradeV3(tradeParams, {
+            headers,
+        });
+        return createTradeResponse;
+    }, PassportErrorType.CREATE_TRADE_ERROR);
 }
 
-async function executeRegisterAndWithdrawERC20({ ethSigner, assetType, starkPublicKey, config, }) {
-    const etherKey = await ethSigner.getAddress();
-    const starkExConfig = config.immutableXConfig;
-    const usersApi = new UsersApi(starkExConfig.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.immutableXConfig.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawERC20(ethSigner, assetType, starkPublicKey, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC20WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const starkExConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ERC20', starkExConfig, {
-        token_address: token.tokenAddress,
-    });
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawERC20({
-            ethSigner,
-            assetType: assetType.asset_type,
-            starkPublicKey,
-            config,
+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);
     }
-    else {
-        return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+    async transfer(request) {
+        return transfer$1({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            transfersApi: this.transfersApi,
+            passportConfig: this.passportConfig,
+        });
     }
-}
-
-async function executeWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdrawAndMint(starkPublicKey, assetType, mintingBlob);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeRegisterAndWithdrawMintableERC721(ethSigner, assetType, starkPublicKey, mintingBlob, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.regsiterAndWithdrawAndMint(etherKey, starkPublicKey, signableResult.operator_signature, assetType, mintingBlob);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-function getMintingBlob(token) {
-    const id = token.data.id;
-    const blueprint = token.data.blueprint || '';
-    return encUtils.sanitizeHex(encUtils.utf8ToHex(`{${id}}:{${blueprint}}`));
-}
-async function completeMintableERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('mintable-asset', 'ERC721', starkExConfig, {
-        id: token.data.id,
-        token_address: token.data.tokenAddress,
-        ...(token.data.blueprint && { blueprint: token.data.blueprint }),
-    });
-    const mintingBlob = getMintingBlob(token);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, starkExConfig);
+    registerOffchain() {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    else {
-        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, starkExConfig);
+    isRegisteredOnchain() {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    }
+    createOrder(request) {
+        return createOrder$1({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            ordersApi: this.ordersApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    cancelOrder(request) {
+        return cancelOrder$1({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            ordersApi: this.ordersApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    createTrade(request) {
+        return createTrade$1({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            tradesApi: this.tradesApi,
+            passportConfig: this.passportConfig,
+        });
+    }
+    batchNftTransfer(request) {
+        return batchNftTransfer({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            transfersApi: this.transfersApi,
+            passportConfig: this.passportConfig,
+        });
     }
-}
-async function executeRegisterAndWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdrawNft(etherKey, starkPublicKey, signableResult.operator_signature, assetType, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawERC721(ethSigner, assetType, starkPublicKey, tokenId, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdrawNft(starkPublicKey, assetType, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeERC721Withdrawal(ethSigner, starkPublicKey, token, config) {
-    const starkExConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ERC721', starkExConfig, {
-        token_id: token.tokenId,
-        token_address: token.tokenAddress,
-    });
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, starkExConfig);
+    exchangeTransfer(request) {
+        return exchangeTransfer$1({
+            request,
+            user: this.user,
+            starkSigner: this.starkSigner,
+            exchangesApi: this.exchangesApi,
+        });
     }
-    else {
-        return executeWithdrawERC721(ethSigner, assetType.asset_type, starkPublicKey, token.tokenId, starkExConfig);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    deposit(deposit) {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-}
-async function completeERC721WithdrawalAction({ ethSigner, starkPublicKey, token, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const tokenAddress = token.tokenAddress;
-    const tokenId = token.tokenId;
-    const starkExConfig = config.immutableXConfig;
-    const mintsApi = new MintsApi(starkExConfig.apiConfiguration);
-    return await mintsApi
-        .getMintableTokenDetailsByClientTokenId({
-        tokenAddress,
-        tokenId,
-    })
-        .then((mintableToken) => completeMintableERC721Withdrawal(ethSigner, starkPublicKey, {
-        type: 'ERC721',
-        data: {
-            id: tokenId,
-            tokenAddress: tokenAddress,
-            blueprint: mintableToken.data.blueprint,
-        },
-    }, config))
-        .catch((error) => {
-        if (error.response?.status === 404) {
-            // token is already minted on L1
-            return completeERC721Withdrawal(ethSigner, starkPublicKey, token, config);
-        }
-        throw error; // unable to recover from any other kind of error
-    });
-}
-
-async function executeRegisterAndWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
-    const etherKey = await ethSigner.getAddress();
-    const usersApi = new UsersApi(config.apiConfiguration);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const contract = Contracts.Registration.connect(config.ethConfiguration.registrationContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.registerAndWithdraw(etherKey, starkPublicKey, signableResult.operator_signature, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function executeWithdrawEth(ethSigner, assetType, starkPublicKey, config) {
-    const contract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await contract.populateTransaction.withdraw(starkPublicKey, assetType);
-    return ethSigner.sendTransaction(populatedTransaction);
-}
-async function completeEthWithdrawalAction({ ethSigner, starkPublicKey, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const starkExConfig = config.immutableXConfig;
-    const assetType = await getEncodeAssetInfo('asset', 'ETH', starkExConfig);
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    prepareWithdrawal(request) {
+        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    else {
-        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, starkExConfig);
+    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);
     }
-}
-
-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,
-            });
+    getAddress() {
+        return Promise.resolve(this.starkSigner.getAddress());
     }
 }
 
-async function createTrade$1({ signers: { ethSigner, starkExSigner }, request, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const ethAddress = await ethSigner.getAddress();
-    const tradesApi = new TradesApi(config.immutableXConfig.apiConfiguration);
-    const signableResult = await tradesApi.getSignableTrade({
-        getSignableTradeRequest: {
-            user: ethAddress,
-            order_id: request.order_id,
-            fees: request.fees,
-        },
-    });
-    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, ethSigner);
-    const starkSignature = await starkExSigner.signMessage(payloadHash);
-    const createTradeResponse = await tradesApi.createTrade({
-        createTradeRequest: {
-            amount_buy: signableResult.data.amount_buy,
-            amount_sell: signableResult.data.amount_sell,
-            asset_id_buy: signableResult.data.asset_id_buy,
-            asset_id_sell: signableResult.data.asset_id_sell,
-            expiration_timestamp: signableResult.data.expiration_timestamp,
-            fee_info: signableResult.data.fee_info,
-            fees: request.fees,
-            include_fees: true,
-            nonce: signableResult.data.nonce,
-            order_id: request.order_id,
-            stark_key: signableResult.data.stark_key,
-            vault_id_buy: signableResult.data.vault_id_buy,
-            vault_id_sell: signableResult.data.vault_id_sell,
-            stark_signature: starkSignature,
-        },
-        xImxEthAddress: ethAddress,
-        xImxEthSignature: ethSignature,
-    });
-    return createTradeResponse.data;
-}
+var Networks;
+(function (Networks) {
+    Networks["PRODUCTION"] = "mainnet";
+    Networks["SANDBOX"] = "goerli";
+})(Networks || (Networks = {}));
 
-async function depositEth({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const user = await ethSigner.getAddress();
-    const data = {
-        decimals: 18,
-    };
-    const amount = parseUnits(deposit.amount, 'wei');
-    const starkExConfig = config.immutableXConfig;
-    const depositsApi = new DepositsApi(starkExConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(starkExConfig.apiConfiguration);
-    const usersApi = new UsersApi(starkExConfig.apiConfiguration);
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    if (!isRegistered) {
-        return executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, starkExConfig, usersApi);
+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);
     }
-    else {
-        return executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, starkExConfig);
+};
+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;
+                }
+            }
+        }
     }
 }
-async function executeRegisterAndDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config, usersApi) {
-    const etherKey = await ethSigner.getAddress();
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const signableResult = await getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi);
-    const populatedTransaction = await coreContract.populateTransaction.registerAndDepositEth(etherKey, starkPublicKey, signableResult.operator_signature, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
-}
-async function executeDepositEth(ethSigner, amount, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction['deposit(uint256,uint256,uint256)'](starkPublicKey, assetType, vaultId);
-    return ethSigner.sendTransaction({ ...populatedTransaction, value: amount });
-}
 
-async function depositERC20({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const { apiConfiguration, ethConfiguration } = config.immutableXConfig;
-    const user = await ethSigner.getAddress();
-    const tokensApi = new TokensApi(apiConfiguration);
-    const depositsApi = new DepositsApi(apiConfiguration);
-    const encodingApi = new EncodingApi(apiConfiguration);
-    const usersApi = new UsersApi(apiConfiguration);
-    // Get decimals for this specific ERC20
-    const token = await tokensApi.getToken({ address: deposit.tokenAddress });
-    const decimals = parseInt(token.data.decimals);
-    const data = {
-        decimals,
-        token_address: deposit.tokenAddress,
-    };
-    const amount = parseUnits(deposit.amount, 0); // 0 to always use undecimalized value
-    // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = Contracts.IERC20.connect(deposit.tokenAddress, ethSigner);
-    const approveTransaction = await tokenContract.populateTransaction.approve(ethConfiguration.coreContractAddress, amount);
-    await ethSigner.sendTransaction(approveTransaction);
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    // Perform encoding on asset details to get an assetType (required for stark contract request)
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-                data: {
-                    token_address: deposit.tokenAddress,
-                },
+const getStarkSigner = async (signer) => {
+    return withPassportError(async () => {
+        const privateKey = await generateLegacyStarkPrivateKey(signer);
+        return createStarkSigner(privateKey);
+    }, PassportErrorType.WALLET_CONNECTION_ERROR);
+};
+
+async function registerPassport({ ethSigner, starkSigner, usersApi }, authorization) {
+    return withPassportError(async () => {
+        const userAddress = await ethSigner.getAddress();
+        const starkPublicKey = await starkSigner.getAddress();
+        const signableResult = await usersApi.getSignableRegistrationOffchain({
+            getSignableRegistrationRequest: {
+                ether_key: userAddress,
+                stark_key: starkPublicKey,
             },
-        },
-    });
-    const 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 { 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);
 }
 
-async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
-    await validateChain(ethSigner, config.immutableXConfig);
-    const user = await ethSigner.getAddress();
-    const { immutableXConfig } = config;
-    const depositsApi = new DepositsApi(immutableXConfig.apiConfiguration);
-    const encodingApi = new EncodingApi(immutableXConfig.apiConfiguration);
-    const usersApi = new UsersApi(immutableXConfig.apiConfiguration);
-    const data = {
-        token_address: deposit.tokenAddress,
-        token_id: deposit.tokenId,
-    };
-    const amount = '1';
-    const getSignableDepositRequest = {
-        user,
-        token: {
-            type: deposit.type,
-            data,
-        },
-        amount: amount.toString(),
-    };
-    const signableDepositResult = await depositsApi.getSignableDeposit({
-        getSignableDepositRequest,
-    });
-    // Perform encoding on asset details to get an assetType (required for stark contract request)
-    const encodingResult = await encodingApi.encodeAsset({
-        assetType: 'asset',
-        encodeAssetRequest: {
-            token: {
-                type: deposit.type,
-                data: {
-                    token_address: deposit.tokenAddress,
-                    token_id: deposit.tokenId,
-                },
-            },
-        },
-    });
-    const assetType = encodingResult.data.asset_type;
-    const starkPublicKey = signableDepositResult.data.stark_key;
-    const vaultId = signableDepositResult.data.vault_id;
-    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
-    // Approve whether an amount of token from an account can be spent by a third-party account
-    const tokenContract = Contracts.IERC721.connect(deposit.tokenAddress, ethSigner);
-    const operator = immutableXConfig.ethConfiguration.coreContractAddress;
-    const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
-    if (!isApprovedForAll) {
-        await tokenContract.setApprovalForAll(operator, true);
+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);
     }
-    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);
+    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,
+        });
+    }
+    async connectImxSilent() {
+        const user = await this.authManager.loginSilent();
+        if (!user) {
+            return null;
+        }
+        return this.getImxProvider(user);
+    }
+    async connectImx() {
+        const user = await this.authManager.login();
+        return this.getImxProvider(user);
+    }
+    async loginCallback() {
+        return this.authManager.loginCallback();
+    }
+    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;
     }
-    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, immutableXConfig);
-}
-async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
-    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
-    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
-    return ethSigner.sendTransaction(populatedTransaction);
 }
 
-async function deposit({ signers, deposit, config }) {
-    switch (deposit.type) {
-        case 'ETH':
-            return depositEth({ signers, deposit, config });
-        case 'ERC20':
-            return depositERC20({ signers, deposit, config });
-        case 'ERC721':
-            return depositERC721({ signers, deposit, config });
-    }
+function isChainValid(chainID, config) {
+    return chainID === config.ethConfiguration.chainID;
+}
+async function validateChain(signer, config) {
+    const chainID = await signer.getChainId();
+    if (!isChainValid(chainID, config))
+        throw new Error('The wallet used for this operation is not connected to the correct network.');
 }
 
-async function exchangeTransfer$1({ signers, request, config, }) {
-    await validateChain(signers.ethSigner, config.immutableXConfig);
-    const exchangeApi = new ExchangesApi(config.immutableXConfig.apiConfiguration);
-    const ethAddress = await signers.ethSigner.getAddress();
-    const transferAmount = request.amount;
-    const signableResult = await exchangeApi.getExchangeSignableTransfer({
-        id: request.transactionID,
+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),
@@ -841,8 +1477,8 @@ async function exchangeTransfer$1({ signers, request, config, }) {
         },
     });
     const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
-    const starkSignature = await signers.starkExSigner.signMessage(payloadHash);
+    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,
@@ -855,8 +1491,7 @@ async function exchangeTransfer$1({ signers, request, config, }) {
         expiration_timestamp: signableResult.data.expiration_timestamp,
         stark_signature: starkSignature,
     };
-    const response = await exchangeApi.createExchangeTransfer({
-        id: request.transactionID,
+    const response = await transfersApi.createTransferV1({
         createTransferRequest: transferSigningParams,
         xImxEthAddress: ethAddress,
         xImxEthSignature: ethSignature,
@@ -868,1060 +1503,1004 @@ async function exchangeTransfer$1({ signers, request, config, }) {
         transfer_id: response?.data.transfer_id,
     };
 }
-
-class GenericIMXProvider {
-    config;
-    signers;
-    constructor(config, ethSigner, starkExSigner) {
-        this.config = config;
-        this.signers = { ethSigner, starkExSigner };
-    }
-    async getAddress() {
-        return await this.signers.ethSigner.getAddress();
-    }
-    registerOffchain() {
-        return registerOffchain(this.signers, this.config);
-    }
-    batchNftTransfer(request) {
-        return batchTransfer({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    cancelOrder(request) {
-        return cancelOrder$1({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    completeWithdrawal(starkPublicKey, token) {
-        return completeWithdrawal({
-            config: this.config,
-            signers: this.signers,
-            token,
-            starkPublicKey,
-        });
-    }
-    createOrder(request) {
-        return createOrder$1({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    createTrade(request) {
-        return createTrade$1({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    deposit(tokenAmount) {
-        return deposit({
-            signers: this.signers,
-            deposit: tokenAmount,
-            config: this.config,
-        });
-    }
-    exchangeTransfer(request) {
-        return exchangeTransfer$1({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-    async isRegisteredOnchain() {
-        const starkPublicKey = await this.signers.starkExSigner.getAddress();
-        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
-    }
-    prepareWithdrawal(request) {
-        return prepareWithdrawal({
-            signers: this.signers,
-            withdrawal: request,
-            config: this.config,
-        });
-    }
-    transfer(request) {
-        return transfer$1({
-            signers: this.signers,
-            request,
-            config: this.config,
-        });
-    }
-}
-
-const WALLET_ACTION = {
-    SWITCH_CHAIN: 'wallet_switchEthereumChain',
-    CONNECT: 'eth_requestAccounts',
-};
-function isRequestableProvider(provider) {
-    return !!provider?.request;
-}
-async function connectProvider(provider, chainID) {
-    await provider.request({ method: WALLET_ACTION.CONNECT });
-    if (chainID) {
-        await provider.request({
-            method: WALLET_ACTION.SWITCH_CHAIN,
-            params: [{ chainId: `0x${chainID.toString(16)}` }],
-        });
+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,
+        };
+    });
+    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 ERRORS = {
-    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
-};
-async function connect$1({ chainID, }) {
-    const provider = (await detectEthereumProvider());
-    if (!isRequestableProvider(provider)) {
-        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
+    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);
     }
-    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);
+    // 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,
+    };
 }
 
-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);
-    }
+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,
+    };
 }
-
-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);
+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,
+    };
 }
 
-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 },
-            });
-        });
+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 registrationContract.isRegistered(starkPublicKey);
     }
-    getIFrame() {
-        return this.iframe;
+    catch (ex) {
+        if (ex.reason === 'USER_UNREGISTERED') {
+            return false;
+        }
+        throw ex;
     }
 }
-
-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 getSignableRegistrationOnchain(etherKey, starkPublicKey, usersApi) {
+    const response = await usersApi.getSignableRegistration({
+        getSignableRegistrationRequest: {
+            ether_key: etherKey,
+            stark_key: starkPublicKey,
+        },
     });
-}
-async function getOrSetupIFrame(env) {
-    const iframe = getIFrame();
-    if (iframe)
-        return iframe;
-    return await setupIFrame(env);
+    return {
+        operator_signature: response.data.operator_signature,
+        payload_hash: response.data.payload_hash,
+    };
 }
 
-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 assertIsDefined = (value) => {
+    if (value !== undefined)
+        return value;
+    throw new Error('undefined field exception');
+};
+async function prepareWithdrawalAction(params) {
+    const { signers: { ethSigner, starkSigner }, type, config, } = params;
+    await validateChain(ethSigner, params.config);
+    const withdrawalsApi = new 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 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() },
-        });
+
+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 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 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);
 }
-const withProviderError = async (fn, customError) => {
-    try {
-        return await fn();
+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,
+        });
     }
-    catch (error) {
-        const errorMessage = customError.message || `${error.message}` || 'UnknownError';
-        throw new ProviderError(errorMessage, customError.type);
+    else {
+        return executeWithdrawERC20(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
-};
+}
 
-class MetaMaskIMXProvider extends GenericIMXProvider {
-    static imxSigner;
-    constructor(config, ethSigner, starkExSigner) {
-        super(config, ethSigner, starkExSigner);
-    }
-    static async connect(config) {
-        return await withProviderError(async () => {
-            const metaMaskProvider = await connect$1({
-                chainID: config.immutableXConfig.ethConfiguration.chainID,
-            });
-            this.imxSigner = await connect(metaMaskProvider, config.baseConfig.environment);
-            return new MetaMaskIMXProvider(config, metaMaskProvider.getSigner(), this.imxSigner);
-        }, { type: ProviderErrorType.WALLET_CONNECTION_ERROR });
+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);
     }
-    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 });
+    else {
+        return executeWithdrawMintableERC721(ethSigner, assetType.asset_type, starkPublicKey, mintingBlob, imxConfig);
     }
-    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 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);
     }
 }
-
-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;
-                }
-            }
+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
+    });
 }
 
-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 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);
 }
-const withPassportError = async (fn, customErrorType) => {
-    try {
-        return await fn();
+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);
     }
-    catch (error) {
-        const errorMessage = `${customErrorType}: ${error.message}` || 'UnknownError';
-        throw new PassportError(errorMessage, customErrorType);
+    else {
+        return executeWithdrawEth(ethSigner, assetType.asset_type, starkPublicKey, imxConfig);
     }
-};
+}
 
-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 });
+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,
+            });
     }
-};
+}
 
-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}`,
+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,
         },
-        mergeClaims: true,
-        loadUserInfo: true,
-        scope: oidcConfiguration.scope,
+    });
+    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,
     };
-    if (oidcConfiguration.audience) {
-        baseConfiguration.extraQueryParams = {
-            audience: oidcConfiguration.audience,
-        };
-    }
-    return baseConfiguration;
-};
-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,
-            },
-            etherKey: passport?.ether_key || '',
-        };
+    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(),
     };
-    async login() {
-        return withPassportError(async () => {
-            const popupWindowFeatures = { width: 400, height: 420 };
-            const oidcUser = await this.userManager.signinPopup({
-                popupWindowFeatures,
-            });
-            return this.mapOidcUserToDomainModel(oidcUser);
-        }, PassportErrorType.AUTHENTICATION_ERROR);
-    }
-    async loginCallback() {
-        return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
-    }
-    async logout() {
-        return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
-    }
-    async getUser() {
-        return withPassportError(async () => {
-            const oidcUser = await this.userManager.getUser();
-            if (!oidcUser) {
-                throw new Error('Failed to retrieve user');
-            }
-            return this.mapOidcUserToDomainModel(oidcUser);
-        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
+    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);
     }
-    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);
+    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 });
+}
 
-class MagicAdapter {
-    magicClient;
-    config;
-    constructor(config) {
-        this.config = config;
-        this.magicClient = new Magic(config.magicPublishableApiKey, {
-            network: config.network,
-            extensions: [new OpenIdExtension()],
-        });
+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);
     }
-    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 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);
+}
 
-var ReceiveMessage;
-(function (ReceiveMessage) {
-    ReceiveMessage["CONFIRMATION_WINDOW_READY"] = "confirmation_window_ready";
-    ReceiveMessage["TRANSACTION_CONFIRMED"] = "transaction_confirmed";
-    ReceiveMessage["TRANSACTION_ERROR"] = "transaction_error";
-})(ReceiveMessage || (ReceiveMessage = {}));
-var SendMessage;
-(function (SendMessage) {
-    SendMessage["TRANSACTION_START"] = "transaction_start";
-})(SendMessage || (SendMessage = {}));
-var TransactionTypes;
-(function (TransactionTypes) {
-    TransactionTypes["CancelOrder"] = "delete:v1/orders";
-    TransactionTypes["CreateOrder"] = "post:v1/orders";
-    TransactionTypes["CreateTrade"] = "post:v1/trades";
-    TransactionTypes["CreateTransfer"] = "post:v1/transfers";
-    TransactionTypes["CreateBatchTransfer"] = "post:v2/transfers";
-})(TransactionTypes || (TransactionTypes = {}));
-const PassportEventType = 'imx_passport_confirmation';
-
-const openPopupCenter = ({ url, title, width, height, }) => {
-    const left = Math.max(0, Math.round(window.screenX + (window.outerWidth - width) / 2));
-    const top = Math.max(0, Math.round(window.screenY + (window.outerHeight - height) / 2));
-    const newWindow = window.open(url, title, `
-      scrollbars=yes,
-      width=${width}, 
-      height=${height}, 
-      top=${top}, 
-      left=${left}
-     `);
-    if (!newWindow) {
-        throw new Error('Failed to open confirmation screen');
-    }
-    newWindow.focus();
-    return newWindow;
-};
-
-const ConfirmationWindowTitle = 'Confirm this transaction';
-const ConfirmationWindowHeight = 380;
-const ConfirmationWindowWidth = 480;
-const ConfirmationWindowClosedPollingDuration = 1000;
-class ConfirmationScreen {
-    config;
-    constructor(config) {
-        this.config = config;
+async function depositERC721({ signers: { ethSigner }, deposit, config, }) {
+    await validateChain(ethSigner, config.immutableXConfig);
+    const user = await ethSigner.getAddress();
+    const { immutableXConfig } = config;
+    const depositsApi = new DepositsApi(immutableXConfig.apiConfiguration);
+    const encodingApi = new EncodingApi(immutableXConfig.apiConfiguration);
+    const usersApi = new UsersApi(immutableXConfig.apiConfiguration);
+    const data = {
+        token_address: deposit.tokenAddress,
+        token_id: deposit.tokenId,
+    };
+    const amount = '1';
+    const getSignableDepositRequest = {
+        user,
+        token: {
+            type: deposit.type,
+            data,
+        },
+        amount: amount.toString(),
+    };
+    const signableDepositResult = await depositsApi.getSignableDeposit({
+        getSignableDepositRequest,
+    });
+    // Perform encoding on asset details to get an assetType (required for stark contract request)
+    const encodingResult = await encodingApi.encodeAsset({
+        assetType: 'asset',
+        encodeAssetRequest: {
+            token: {
+                type: deposit.type,
+                data: {
+                    token_address: deposit.tokenAddress,
+                    token_id: deposit.tokenId,
+                },
+            },
+        },
+    });
+    const assetType = encodingResult.data.asset_type;
+    const starkPublicKey = signableDepositResult.data.stark_key;
+    const vaultId = signableDepositResult.data.vault_id;
+    const isRegistered = await isRegisteredOnChain(starkPublicKey, ethSigner, config);
+    // Approve whether an amount of token from an account can be spent by a third-party account
+    const tokenContract = Contracts.IERC721.connect(deposit.tokenAddress, ethSigner);
+    const operator = immutableXConfig.ethConfiguration.coreContractAddress;
+    const isApprovedForAll = await tokenContract.isApprovedForAll(user, operator);
+    if (!isApprovedForAll) {
+        await tokenContract.setApprovalForAll(operator, true);
     }
-    postMessage(destinationWindow, accessToken, message) {
-        destinationWindow.postMessage({
-            eventType: PassportEventType,
-            accessToken,
-            ...message,
-        }, this.config.passportDomain);
+    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);
     }
-    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);
-        });
+    return executeDepositERC721(ethSigner, deposit.tokenId, assetType, starkPublicKey, vaultId, immutableXConfig);
+}
+async function executeDepositERC721(ethSigner, tokenId, assetType, starkPublicKey, vaultId, config) {
+    const coreContract = Contracts.Core.connect(config.ethConfiguration.coreContractAddress, ethSigner);
+    const populatedTransaction = await coreContract.populateTransaction.depositNft(starkPublicKey, assetType, vaultId, tokenId);
+    return ethSigner.sendTransaction(populatedTransaction);
+}
+
+async function deposit({ signers, deposit, config }) {
+    switch (deposit.type) {
+        case 'ETH':
+            return depositEth({ signers, deposit, config });
+        case 'ERC20':
+            return depositERC20({ signers, deposit, config });
+        case 'ERC721':
+            return depositERC721({ signers, deposit, config });
     }
 }
 
-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,
+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 signableResult = await transfersApi.getSignableTransferV1({
-            getSignableTransferRequest,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const ethSignature = await signRaw(signableMessage, signers.ethSigner);
+    const starkSignature = await signers.starkSigner.signMessage(payloadHash);
+    const transferSigningParams = {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        sender_stark_key: signableResult.data.sender_stark_key,
+        sender_vault_id: signableResult.data.sender_vault_id,
+        receiver_stark_key: signableResult.data.receiver_stark_key,
+        receiver_vault_id: signableResult.data.receiver_vault_id,
+        asset_id: signableResult.data.asset_id,
+        amount: signableResult.data.amount,
+        nonce: signableResult.data.nonce,
+        expiration_timestamp: signableResult.data.expiration_timestamp,
+        stark_signature: starkSignature,
+    };
+    const response = await exchangeApi.createExchangeTransfer({
+        id: request.transactionID,
+        createTransferRequest: transferSigningParams,
+        xImxEthAddress: ethAddress,
+        xImxEthSignature: ethSignature,
+    });
+    return {
+        sent_signature: response?.data.sent_signature,
+        status: response?.data.status?.toString(),
+        time: response?.data.time,
+        transfer_id: response?.data.transfer_id,
+    };
+}
+
+class GenericIMXProvider {
+    config;
+    signers;
+    constructor(config, ethSigner, starkSigner) {
+        this.config = config;
+        this.signers = { ethSigner, starkSigner };
+    }
+    async getAddress() {
+        return await this.signers.ethSigner.getAddress();
+    }
+    registerOffchain() {
+        return registerOffchain(this.signers, this.config);
+    }
+    batchNftTransfer(request) {
+        return batchTransfer({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateTransfer,
-            transactionData: getSignableTransferRequest,
+    }
+    cancelOrder(request) {
+        return cancelOrder({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        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,
-            };
+    }
+    completeWithdrawal(starkPublicKey, token) {
+        return completeWithdrawal({
+            config: this.config,
+            signers: this.signers,
+            token,
+            starkPublicKey,
         });
-        const getSignableTransferRequestV2 = {
-            sender_ether_key: ethAddress,
-            signable_requests: signableRequests,
-        };
-        const signableResult = await transfersApi.getSignableTransfer({
-            getSignableTransferRequestV2,
+    }
+    createOrder(request) {
+        return createOrder({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const popupWindowSize = { width: 480, height: 784 };
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateBatchTransfer,
-            transactionData: getSignableTransferRequestV2,
-        }, popupWindowSize);
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
-            const starkSignature = await starkSigner.signMessage(resp.payload_hash);
-            return {
-                sender_vault_id: resp.sender_vault_id,
-                receiver_stark_key: resp.receiver_stark_key,
-                receiver_vault_id: resp.receiver_vault_id,
-                asset_id: resp.asset_id,
-                amount: resp.amount,
-                nonce: resp.nonce,
-                expiration_timestamp: resp.expiration_timestamp,
-                stark_signature: starkSignature,
-            };
-        }));
-        const transferSigningParams = {
-            sender_stark_key: signableResult.data.sender_stark_key,
-            requests,
-        };
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const response = await transfersApi.createTransfer({
-            createTransferRequestV2: transferSigningParams,
-        }, { headers });
-        return {
-            transfer_ids: response?.data.transfer_ids,
-        };
-    }, PassportErrorType.TRANSFER_ERROR);
-}
-
-const ERC721 = 'ERC721';
-async function createOrder({ starkSigner, user, request, ordersApi, passportConfig, }) {
-    return withPassportError(async () => {
-        const ethAddress = user.etherKey;
-        const amountSell = request.sell.type === ERC721 ? '1' : request.sell.amount;
-        const amountBuy = request.buy.type === ERC721 ? '1' : request.buy.amount;
-        const getSignableOrderRequestV3 = {
-            user: ethAddress,
-            amount_buy: amountBuy,
-            token_buy: convertToSignableToken(request.buy),
-            amount_sell: amountSell,
-            token_sell: convertToSignableToken(request.sell),
-            fees: request.fees,
-            expiration_timestamp: request.expiration_timestamp,
-        };
-        const getSignableOrderResponse = await ordersApi.getSignableOrder({
-            getSignableOrderRequestV3,
+    }
+    createTrade(request) {
+        return createTrade({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateOrder,
-            transactionData: getSignableOrderRequestV3,
+    }
+    deposit(tokenAmount) {
+        return deposit({
+            signers: this.signers,
+            deposit: tokenAmount,
+            config: this.config,
         });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const { payload_hash: payloadHash } = getSignableOrderResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const signableResultData = getSignableOrderResponse.data;
-        const orderParams = {
-            createOrderRequest: {
-                include_fees: true,
-                fees: request.fees,
-                stark_signature: starkSignature,
-                amount_buy: signableResultData.amount_buy,
-                amount_sell: signableResultData.amount_sell,
-                asset_id_buy: signableResultData.asset_id_buy,
-                asset_id_sell: signableResultData.asset_id_sell,
-                expiration_timestamp: signableResultData.expiration_timestamp,
-                nonce: signableResultData.nonce,
-                stark_key: signableResultData.stark_key,
-                vault_id_buy: signableResultData.vault_id_buy,
-                vault_id_sell: signableResultData.vault_id_sell,
-            },
-        };
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const createOrderResponse = await ordersApi.createOrder(orderParams, {
-            headers,
+    }
+    exchangeTransfer(request) {
+        return exchangeTransfer({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        return {
-            ...createOrderResponse.data,
-        };
-    }, PassportErrorType.CREATE_ORDER_ERROR);
-}
-async function cancelOrder({ user, starkSigner, request, ordersApi, passportConfig, }) {
-    return withPassportError(async () => {
-        const getSignableCancelOrderRequest = {
-            order_id: request.order_id,
-        };
-        const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrder({
-            getSignableCancelOrderRequest,
+    }
+    async isRegisteredOnchain() {
+        const starkPublicKey = await this.signers.starkSigner.getAddress();
+        return isRegisteredOnChain(starkPublicKey, this.signers.ethSigner, this.config);
+    }
+    prepareWithdrawal(request) {
+        return prepareWithdrawal({
+            signers: this.signers,
+            withdrawal: request,
+            config: this.config,
         });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CancelOrder,
-            transactionData: getSignableCancelOrderRequest,
+    }
+    transfer(request) {
+        return transfer({
+            signers: this.signers,
+            request,
+            config: this.config,
         });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const cancelOrderResponse = await ordersApi.cancelOrder({
-            id: request.order_id.toString(),
-            cancelOrderRequest: {
-                order_id: request.order_id,
-                stark_signature: starkSignature,
-            },
-        }, { headers });
-        return {
-            order_id: cancelOrderResponse.data.order_id,
-            status: cancelOrderResponse.data.status,
-        };
-    }, PassportErrorType.CANCEL_ORDER_ERROR);
+    }
 }
 
-async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
-    return withPassportError(async () => {
-        const ethAddress = user.etherKey;
-        const transferAmount = request.amount;
-        const signableResult = await exchangesApi.getExchangeSignableTransfer({
-            id: request.transactionID,
-            getSignableTransferRequest: {
-                sender: ethAddress,
-                token: convertToSignableToken(request),
-                amount: transferAmount,
-                receiver: request.receiver,
-            },
+const 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 starkAddress = await starkSigner.getAddress();
-        const { payload_hash: payloadHash } = signableResult.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const transferSigningParams = {
-            sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
-            sender_vault_id: signableResult.data.sender_vault_id,
-            receiver_stark_key: signableResult.data.receiver_stark_key,
-            receiver_vault_id: signableResult.data.receiver_vault_id,
-            asset_id: signableResult.data.asset_id,
-            amount: signableResult.data.amount,
-            nonce: signableResult.data.nonce,
-            expiration_timestamp: signableResult.data.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const response = await exchangesApi.createExchangeTransfer({
-            id: request.transactionID,
-            createTransferRequest: transferSigningParams,
-        }, { headers });
-        return {
-            sent_signature: response?.data.sent_signature,
-            status: response?.data.status?.toString(),
-            time: response?.data.time,
-            transfer_id: response?.data.transfer_id,
-        };
-    }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
+    }
 }
 
-async function createTrade({ request, tradesApi, user, starkSigner, passportConfig, }) {
-    return withPassportError(async () => {
-        const ethAddress = user.etherKey;
-        const getSignableTradeRequest = {
-            expiration_timestamp: request.expiration_timestamp,
-            fees: request.fees,
-            order_id: request.order_id,
-            user: ethAddress,
-        };
-        const getSignableTradeResponse = await tradesApi.getSignableTrade({
-            getSignableTradeRequest,
-        });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateTrade,
-            transactionData: getSignableTradeRequest,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const { payload_hash: payloadHash } = getSignableTradeResponse.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const { data: signableResultData } = getSignableTradeResponse;
-        const tradeParams = {
-            createTradeRequest: {
-                include_fees: true,
-                fees: request?.fees,
-                stark_signature: starkSignature,
-                order_id: request?.order_id,
-                fee_info: signableResultData.fee_info,
-                amount_buy: signableResultData.amount_buy,
-                amount_sell: signableResultData.amount_sell,
-                asset_id_buy: signableResultData.asset_id_buy,
-                asset_id_sell: signableResultData.asset_id_sell,
-                expiration_timestamp: signableResultData.expiration_timestamp,
-                nonce: signableResultData.nonce,
-                stark_key: signableResultData.stark_key,
-                vault_id_buy: signableResultData.vault_id_buy,
-                vault_id_sell: signableResultData.vault_id_sell,
-            },
-        };
-        const headers = { Authorization: 'Bearer ' + user.accessToken };
-        const { data: createTradeResponse } = await tradesApi.createTradeV3(tradeParams, {
-            headers,
-        });
-        return createTradeResponse;
-    }, PassportErrorType.CREATE_TRADE_ERROR);
+const ERRORS = {
+    PROVIDER_NOT_FOUND: 'The Metamask provider was not found',
+};
+async function connect$1({ chainID, }) {
+    const provider = (await detectEthereumProvider());
+    if (!isRequestableProvider(provider)) {
+        throw new Error(ERRORS.PROVIDER_NOT_FOUND);
+    }
+    await connectProvider(provider, chainID);
+    // NOTE: if we want to listen to Metamask events in the future, we can add a
+    // listener here.
+    return new ethers.providers.Web3Provider(provider);
 }
 
-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);
+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);
     }
-    async transfer(request) {
-        return transfer({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
-            passportConfig: this.passportConfig,
-        });
+}
+
+function messageResponseListener(iframe, event, eventType, callback) {
+    if (iframe && event.source !== iframe.contentWindow) {
+        return;
     }
-    registerOffchain() {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    const l2WalletMessage = event.data;
+    if (l2WalletMessage.type !== eventType) {
+        return;
     }
-    isRegisteredOnchain() {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    callback(l2WalletMessage.details);
+}
+
+class ImxSigner {
+    publicAddress;
+    iframe;
+    constructor(publicAddress, iframe) {
+        this.publicAddress = publicAddress;
+        this.iframe = iframe;
     }
-    createOrder(request) {
-        return createOrder({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
-            passportConfig: this.passportConfig,
-        });
+    getAddress() {
+        return this.publicAddress;
     }
-    cancelOrder(request) {
-        return cancelOrder({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
-            passportConfig: this.passportConfig,
+    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 },
+            });
         });
     }
-    createTrade(request) {
-        return createTrade({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            tradesApi: this.tradesApi,
-            passportConfig: this.passportConfig,
-        });
+    getIFrame() {
+        return this.iframe;
     }
-    batchNftTransfer(request) {
-        return batchNftTransfer({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
-            passportConfig: this.passportConfig,
+}
+
+const IMX_WALLET_IFRAME_ID = 'imx-wallet-app';
+const IMX_WALLET_IFRAME_HOSTS = {
+    [Environment.SANDBOX]: 'https://wallets.sandbox.immutable.com',
+    [Environment.PRODUCTION]: 'https://wallets.immutable.com',
+};
+const IMX_WALLET_IFRAME_STYLE = 'display: none;';
+function getIFrame() {
+    return document.querySelector(`iframe#${IMX_WALLET_IFRAME_ID}`);
+}
+async function setupIFrame(env) {
+    return new Promise((resolve) => {
+        const iframe = document.createElement('iframe');
+        iframe.setAttribute('id', IMX_WALLET_IFRAME_ID);
+        iframe.setAttribute('src', IMX_WALLET_IFRAME_HOSTS[env]);
+        iframe.setAttribute('style', IMX_WALLET_IFRAME_STYLE);
+        document.body.appendChild(iframe);
+        iframe.onload = () => resolve(iframe);
+    });
+}
+async function getOrSetupIFrame(env) {
+    const iframe = getIFrame();
+    if (iframe)
+        return iframe;
+    return await setupIFrame(env);
+}
+
+const DEFAULT_CONNECTION_MESSAGE = 'Only sign this request if you’ve initiated an action with Immutable X.';
+const CONNECTION_FAILED_ERROR = 'The L2 IMX Wallet connection has failed';
+async function connect(l1Provider, env) {
+    const l1Signer = l1Provider.getSigner();
+    const address = await l1Signer.getAddress();
+    const signature = await l1Signer.signMessage(DEFAULT_CONNECTION_MESSAGE);
+    const iframe = await getOrSetupIFrame(env);
+    return new Promise((resolve, reject) => {
+        const listener = (event) => {
+            messageResponseListener(iframe, event, ResponseEventType.CONNECT_WALLET_RESPONSE, (messageDetails) => {
+                window.removeEventListener(COMMUNICATION_TYPE, listener);
+                if (!messageDetails.success) {
+                    reject(new Error(CONNECTION_FAILED_ERROR));
+                }
+                resolve(new ImxSigner(messageDetails.data.starkPublicKey, iframe));
+            });
+        };
+        window.addEventListener(COMMUNICATION_TYPE, listener);
+        postRequestMessage(iframe, {
+            type: RequestEventType.CONNECT_WALLET_REQUEST,
+            details: { ethAddress: address, signature },
         });
-    }
-    exchangeTransfer(request) {
-        return exchangeTransfer({
-            request,
-            user: this.user,
-            starkSigner: this.starkSigner,
-            exchangesApi: this.exchangesApi,
+    });
+}
+async function disconnect(imxSigner) {
+    const iframe = imxSigner.getIFrame();
+    return new Promise((resolve, reject) => {
+        const listener = (event) => {
+            messageResponseListener(iframe, event, ResponseEventType.DISCONNECT_WALLET_RESPONSE, (messageDetails) => {
+                window.removeEventListener(COMMUNICATION_TYPE, listener);
+                if (!messageDetails.success && messageDetails.error) {
+                    reject(messageDetails.error);
+                }
+                iframe.remove();
+                resolve();
+            });
+        };
+        window.addEventListener(COMMUNICATION_TYPE, listener);
+        postRequestMessage(iframe, {
+            type: RequestEventType.DISCONNECT_WALLET_REQUEST,
+            details: { starkPublicKey: imxSigner.getAddress() },
         });
+    });
+}
+
+var ProviderErrorType;
+(function (ProviderErrorType) {
+    ProviderErrorType["PROVIDER_CONNECTION_ERROR"] = "PROVIDER_CONNECTION_ERROR";
+    ProviderErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
+})(ProviderErrorType || (ProviderErrorType = {}));
+class ProviderError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    deposit(deposit) {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+}
+const withProviderError = async (fn, customError) => {
+    try {
+        return await fn();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    prepareWithdrawal(request) {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    catch (error) {
+        const errorMessage = customError.message || `${error.message}` || 'UnknownError';
+        throw new ProviderError(errorMessage, customError.type);
     }
-    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);
+};
+
+class MetaMaskIMXProvider extends GenericIMXProvider {
+    static imxSigner;
+    constructor(config, ethSigner, starkSigner) {
+        super(config, ethSigner, starkSigner);
     }
-    getAddress() {
-        return Promise.resolve(this.starkSigner.getAddress());
+    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 });
     }
-}
-
-var Networks;
-(function (Networks) {
-    Networks["PRODUCTION"] = "mainnet";
-    Networks["SANDBOX"] = "goerli";
-})(Networks || (Networks = {}));
-
-const validateConfiguration = (configuration, requiredKeys, prefix) => {
-    const missingKeys = requiredKeys
-        .map((key) => !configuration[key] && key)
-        .filter((n) => n)
-        .join(', ');
-    if (missingKeys !== '') {
-        const errorMessage = prefix
-            ? `${prefix} - ${missingKeys} cannot be null`
-            : `${missingKeys} cannot be null`;
-        throw new PassportError(errorMessage, PassportErrorType.INVALID_CONFIGURATION);
+    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 });
     }
-};
-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;
+    static async signMessage(message) {
+        if (!this.imxSigner) {
+            throw new ProviderError('Attempted to sign a message with the MetaMask IMX provider without an established connection', ProviderErrorType.PROVIDER_CONNECTION_ERROR);
+        }
+        return withProviderError(async () => {
+            return await this.imxSigner.signMessage(message);
+        }, { type: ProviderErrorType.PROVIDER_CONNECTION_ERROR });
+    }
+}
+
+class ProviderConfiguration {
+    immutableXConfig;
+    baseConfig;
+    constructor({ baseConfig, overrides }) {
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            this.immutableXConfig = overrides.immutableXConfig;
         }
         else {
             switch (baseConfig.environment) {
                 case 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';
+                    this.immutableXConfig = Config.SANDBOX;
                     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';
+                    this.immutableXConfig = Config.PRODUCTION;
                     break;
                 }
             }
@@ -1929,108 +2508,6 @@ class PassportConfiguration {
     }
 }
 
-const getStarkSigner = async (signer) => {
-    return withPassportError(async () => {
-        const privateKey = await generateLegacyStarkPrivateKey(signer);
-        return createStarkSigner(privateKey);
-    }, PassportErrorType.WALLET_CONNECTION_ERROR);
-};
-
-async function registerPassport({ ethSigner, starkSigner, usersApi }, authorization) {
-    return withPassportError(async () => {
-        const userAddress = await ethSigner.getAddress();
-        const starkPublicKey = await starkSigner.getAddress();
-        const signableResult = await usersApi.getSignableRegistrationOffchain({
-            getSignableRegistrationRequest: {
-                ether_key: userAddress,
-                stark_key: starkPublicKey,
-            },
-        });
-        const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-        const ethSignature = await signRaw(signableMessage, ethSigner);
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const response = await usersApi.registerPassportUser({
-            authorization: `Bearer ` + authorization,
-            registerPassportUserRequest: {
-                eth_signature: ethSignature,
-                ether_key: userAddress,
-                stark_signature: starkSignature,
-                stark_key: starkPublicKey,
-            },
-        });
-        return response.statusText;
-    }, PassportErrorType.USER_REGISTRATION_ERROR);
-}
-
-class Passport {
-    authManager;
-    magicAdapter;
-    config;
-    constructor(passportModuleConfiguration) {
-        const passportConfiguration = new PassportConfiguration(passportModuleConfiguration);
-        this.config = passportConfiguration;
-        this.authManager = new AuthManager(this.config);
-        this.magicAdapter = new MagicAdapter(this.config);
-    }
-    async connectImx() {
-        const user = await this.authManager.login();
-        if (!user.idToken) {
-            throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
-        }
-        const provider = await this.magicAdapter.login(user.idToken);
-        const ethSigner = provider.getSigner();
-        const starkSigner = await getStarkSigner(ethSigner);
-        if (!user.etherKey) {
-            const updatedUser = await this.registerUser(ethSigner, starkSigner, user.accessToken);
-            return new PassportImxProvider({
-                user: updatedUser,
-                starkSigner,
-                passportConfig: this.config,
-            });
-        }
-        const userWithEtherKey = user;
-        return new PassportImxProvider({
-            user: userWithEtherKey,
-            starkSigner,
-            passportConfig: this.config,
-        });
-    }
-    async loginCallback() {
-        return this.authManager.loginCallback();
-    }
-    async logout() {
-        return this.authManager.logout();
-    }
-    async getUserInfo() {
-        const user = await this.authManager.getUser();
-        return user.profile;
-    }
-    async getIdToken() {
-        const user = await this.authManager.getUser();
-        return user.idToken;
-    }
-    async getAccessToken() {
-        const user = await this.authManager.getUser();
-        return user.accessToken;
-    }
-    async registerUser(userAdminKeySigner, starkSigner, jwt) {
-        const configuration = new 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;
-    }
-}
-
 function $parcel$interopDefault(a) {
   return a && a.__esModule ? a.default : a;
 }
@@ -2187,7 +2664,9 @@ let $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";
@@ -2213,12 +2692,6 @@ let $a8bc256d81a5e2c1$export$a22d4e0719ee6def;
 (function(CheckoutInternalErrorType) {
     CheckoutInternalErrorType["REJECTED_SWITCH_AFTER_ADDING_NETWORK"] = "REJECTED_SWITCH_AFTER_ADDING_NETWORK";
 })($a8bc256d81a5e2c1$export$a22d4e0719ee6def || ($a8bc256d81a5e2c1$export$a22d4e0719ee6def = {}));
-class $a8bc256d81a5e2c1$export$620a0d5f1b58ea1d extends Error {
-    constructor(type){
-        super("Checkout internal error");
-        this.type = type;
-    }
-}
 const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
     try {
         return await fn();
@@ -2241,6 +2714,70 @@ const $a8bc256d81a5e2c1$export$bacc563de539c6c3 = async (fn, customError)=>{
 
 /* eslint-disable @typescript-eslint/no-explicit-any */ 
 
+/* eslint-disable @typescript-eslint/no-explicit-any */ 
+
+
+
+async function $c99672cf2294e839$export$2d040992269b4717(providerPreference) {
+    const provider = await $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference);
+    if (!provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR, {
+        details: `Unsupported provider for ${providerPreference}`
+    });
+    let accounts = [];
+    try {
+        accounts = await provider.provider.request({
+            method: (0, $4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION,
+            params: []
+        });
+    } catch (err) {
+        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Check wallet connection request failed`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_FAILED_ERROR, {
+            rpcMethod: ($4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION
+        });
+    }
+    // accounts[0] will have the active account if connected.
+    return {
+        isConnected: accounts && accounts.length > 0,
+        walletAddress: accounts[0] ?? ""
+    };
+}
+async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
+    const web3Provider = await $c99672cf2294e839$var$getWalletProviderForPreference(params.providerPreference);
+    await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        if (!web3Provider || !web3Provider?.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR, {
+            details: `Unsupported provider for ${params.providerPreference}`
+        });
+        // this makes the request to the wallet to connect i.e request eth accounts ('eth_requestAccounts')
+        await web3Provider.provider.request({
+            method: ($4f91c5f280efe242$export$a130407f3423b97d).CONNECT,
+            params: []
+        });
+    }, {
+        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR
+    });
+    return web3Provider;
+}
+async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
+    let web3Provider = null;
+    switch(providerPreference){
+        case ($d176a05e966364ba$export$3bfad4d03ada24c4).METAMASK:
+            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
+            break;
+        default:
+            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_PREFERENCE_ERROR);
+    }
+    return web3Provider;
+}
+async function $c99672cf2294e839$var$getMetaMaskProvider() {
+    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
+        return await (detectEthereumProvider)();
+    }, {
+        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR
+    });
+    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR);
+    return new (Web3Provider)(provider);
+}
+
+
 var $497c134ecbc8a50f$exports = {};
 $497c134ecbc8a50f$exports = JSON.parse('[{"chainId":1},{"chainId":5},{"chainId":137}]');
 
@@ -2266,25 +2803,28 @@ async function $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider) {
         type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).GET_NETWORK_INFO_ERROR
     });
 }
-async function $de192de6ef100f9f$export$b827d9418aeb5dbd(provider, chainId) {
+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 (!provider || !provider.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_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);
+        await $de192de6ef100f9f$var$switchNetworkInWallet(currentProvider, chainId);
     } catch (err) {
         if (err.code === $de192de6ef100f9f$var$UNRECOGNISED_CHAIN_ERROR_CODE) try {
-            await $de192de6ef100f9f$var$addNetworkToWallet(provider, chainId);
-            if ((await provider.getNetwork()).chainId !== chainId) // user didn't actually switch
-            throw new (0, $a8bc256d81a5e2c1$export$620a0d5f1b58ea1d)((0, $a8bc256d81a5e2c1$export$a22d4e0719ee6def).REJECTED_SWITCH_AFTER_ADDING_NETWORK);
+            await $de192de6ef100f9f$var$addNetworkToWallet(currentProvider, chainId);
         } catch (err) {
-            if (err?.type === ($a8bc256d81a5e2c1$export$a22d4e0719ee6def).REJECTED_SWITCH_AFTER_ADDING_NETWORK) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
             throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled add network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
         }
         else throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("User cancelled switch network request", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR);
     }
+    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];
@@ -2293,7 +2833,8 @@ 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  }) {
@@ -2433,75 +2974,12 @@ 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, {
-        details: `Unsupported provider for ${providerPreference}`
-    });
-    let accounts = [];
-    try {
-        accounts = await provider.provider.request({
-            method: (0, $4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION,
-            params: []
-        });
-    } catch (err) {
-        throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)(`Check wallet connection request failed`, ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_FAILED_ERROR, {
-            rpcMethod: ($4f91c5f280efe242$export$a130407f3423b97d).CHECK_CONNECTION
-        });
-    }
-    // accounts[0] will have the active account if connected.
-    return {
-        isConnected: accounts && accounts.length > 0,
-        walletAddress: accounts[0] ?? ""
-    };
-}
-async function $c99672cf2294e839$export$fba2f6c3656e07c1(params) {
-    const web3Provider = await $c99672cf2294e839$var$getWalletProviderForPreference(params.providerPreference);
-    await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        if (!web3Provider || !web3Provider?.provider?.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Incompatible provider", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_REQUEST_MISSING_ERROR, {
-            details: `Unsupported provider for ${params.providerPreference}`
-        });
-        // this makes the request to the wallet to connect i.e request eth accounts ('eth_requestAccounts')
-        await web3Provider.provider.request({
-            method: ($4f91c5f280efe242$export$a130407f3423b97d).CONNECT,
-            params: []
-        });
-    }, {
-        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).USER_REJECTED_REQUEST_ERROR
-    });
-    return web3Provider;
-}
-async function $c99672cf2294e839$var$getWalletProviderForPreference(providerPreference) {
-    let web3Provider = null;
-    switch(providerPreference){
-        case ($d176a05e966364ba$export$3bfad4d03ada24c4).METAMASK:
-            web3Provider = await $c99672cf2294e839$var$getMetaMaskProvider();
-            break;
-        default:
-            throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("Provider preference is not supported", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).PROVIDER_PREFERENCE_ERROR);
-    }
-    return web3Provider;
-}
-async function $c99672cf2294e839$var$getMetaMaskProvider() {
-    const provider = await ($a8bc256d81a5e2c1$export$bacc563de539c6c3)(async ()=>{
-        return await (detectEthereumProvider)();
-    }, {
-        type: ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR
-    });
-    if (!provider || !provider.request) throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("No MetaMask provider installed.", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).METAMASK_PROVIDER_ERROR);
-    return new (Web3Provider)(provider);
-}
-
 
 
 
 
 var $6f3c55a615003cbf$exports = {};
-$6f3c55a615003cbf$exports = JSON.parse('[{"connectionProvider":"metamask","icon":"some-icon-url","name":"MetaMask","description":"complete web3 wallet solution","platform":["mobile","desktop"]},{"connectionProvider":"passport","icon":"pp-icon","name":"Passport","description":"Web3 with your email!","platform":["mobile"]},{"connectionProvider":"gamestop","icon":"gme-icon","name":"GameStop","description":"Never stopping the game!","platform":["desktop"]}]');
+$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  }) {
@@ -2540,11 +3018,23 @@ 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 networkInfo = await $de192de6ef100f9f$export$79f13b4cfaaf0d09(provider);
         return {
@@ -2552,29 +3042,72 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
             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);
     }
-    async getNetworkAllowList(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);
     }
-    async getTokenAllowList(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);
     }
-    async getWalletsAllowList(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);
     }
-    async sendTransaction(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);
     }
-    async getNetworkInfo(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);
     }
 }
@@ -2669,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, $d71a87afc3136184$export$e72e7f9969a47dd3 as ConnectEventType, $d176a05e966364ba$export$3bfad4d03ada24c4 as ConnectionProviders, Environment, GenericIMXProvider, $88e4c575901cd68c$export$5a0ace85cae72d45 as IMTBLWidgetEvents, ImmutableConfiguration, MetaMaskIMXProvider, $9234b4c577442a97$export$95be4ae94445245a as Network, $a47e48dd2c04791b$export$1f05a55fe0680cc7 as NetworkFilterTypes, Passport, PassportConfiguration, PassportError, ProviderConfiguration, StarkExAPIFactory, StarkExConfiguration, $5d497088f13bb116$export$140a49745ab55563 as SwapEventType, $08d5ddc39acd6833$export$fd9b17d87f4121d2 as TokenFilterTypes, $9d0f1783d4d36e8a$export$d9be06b70b28c742 as WalletEventType, $4f91c5f280efe242$export$a75605c67ea83a5a as WalletFilterTypes, $9234b4c577442a97$export$c88931fdc51854eb as WidgetTheme };
+export { $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 };