@imtbl/sdk 0.1.3 → 0.1.5-alpha

package/dist/passport.js

@@ -1,4 +1,4 @@
-import { Configuration, UsersApi, TransfersApi, OrdersApi, ExchangesApi, TradesApi, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
+import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 import { UserManager } from 'oidc-client-ts';
 import { ethers } from 'ethers';
 import { Magic } from 'magic-sdk';
@@ -6,6 +6,515 @@ import { OpenIdExtension } from '@magic-ext/oidc';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
 
+var Environment;
+(function (Environment) {
+    Environment["PRODUCTION"] = "production";
+    Environment["SANDBOX"] = "sandbox";
+})(Environment || (Environment = {}));
+
+/**
+ * Set `sdkVersion` on config
+ */
+const production = () => Config.createConfig({
+    basePath: 'https://api.x.immutable.com',
+    chainID: 1,
+    coreContractAddress: '0x5FDCCA53617f4d2b9134B29090C87D01058e27e9',
+    registrationContractAddress: '0x72a06bf2a1CE5e39cBA06c0CAb824960B587d64c',
+    sdkVersion: 'ts-immutable-sdk-0.1.5-alpha',
+});
+/**
+ * Set `sdkVersion` on config
+ */
+const sandbox = () => Config.createConfig({
+    basePath: 'https://api.sandbox.x.immutable.com',
+    chainID: 5,
+    coreContractAddress: '0x7917eDb51ecD6CdB3F9854c3cc593F33de10c623',
+    registrationContractAddress: '0x1C97Ada273C9A52253f463042f29117090Cd7D83',
+    sdkVersion: 'ts-immutable-sdk-0.1.5-alpha',
+});
+class ImxConfiguration {
+    immutableXConfig;
+    baseConfig;
+    constructor({ baseConfig, overrides }) {
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            this.immutableXConfig = overrides.immutableXConfig;
+        }
+        else {
+            switch (baseConfig.environment) {
+                case Environment.SANDBOX: {
+                    this.immutableXConfig = sandbox();
+                    break;
+                }
+                case Environment.PRODUCTION: {
+                    this.immutableXConfig = production();
+                    break;
+                }
+                default: {
+                    this.immutableXConfig = sandbox();
+                }
+            }
+        }
+    }
+}
+
+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 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 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 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 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 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 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 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 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 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) {
     // This is because golang appends a recovery param
@@ -67,12 +576,6 @@ function convertToSignableToken(token) {
     }
 }
 
-var Environment;
-(function (Environment) {
-    Environment["PRODUCTION"] = "production";
-    Environment["SANDBOX"] = "sandbox";
-})(Environment || (Environment = {}));
-
 var PassportErrorType;
 (function (PassportErrorType) {
     PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
@@ -136,9 +639,9 @@ const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
             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}`,
+            end_session_endpoint: `${authenticationDomain}/v2/logout`
+                + `?returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}`
+                + `&client_id=${oidcConfiguration.clientId}`,
         },
         mergeClaims: true,
         loadUserInfo: true,
@@ -158,7 +661,7 @@ class AuthManager {
         this.config = config;
         this.userManager = new UserManager(getAuthConfiguration(config));
     }
-    mapOidcUserToDomainModel = (oidcUser) => {
+    static mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
         return {
             expired: oidcUser.expired,
@@ -179,7 +682,7 @@ class AuthManager {
             const oidcUser = await this.userManager.signinPopup({
                 popupWindowFeatures,
             });
-            return this.mapOidcUserToDomainModel(oidcUser);
+            return AuthManager.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.AUTHENTICATION_ERROR);
     }
     async loginCallback() {
@@ -198,7 +701,7 @@ class AuthManager {
             if (!oidcUser) {
                 return null;
             }
-            return this.mapOidcUserToDomainModel(oidcUser);
+            return AuthManager.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.SILENT_LOGIN_ERROR);
     }
     async getUser() {
@@ -207,7 +710,7 @@ class AuthManager {
             if (!oidcUser) {
                 return null;
             }
-            return this.mapOidcUserToDomainModel(oidcUser);
+            return AuthManager.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
     }
     async requestRefreshTokenAfterRegistration() {
@@ -215,18 +718,18 @@ class AuthManager {
             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;
+                const metadataExists = !!passportMetadata?.ether_key
+                    && !!passportMetadata?.stark_key
+                    && !!passportMetadata?.user_admin_key;
                 if (metadataExists) {
                     return user;
                 }
-                return Promise.reject('user wallet addresses not exist');
+                return Promise.reject(new Error('user wallet addresses not exist'));
             });
             if (!updatedUser) {
                 return null;
             }
-            return this.mapOidcUserToDomainModel(updatedUser);
+            return AuthManager.mapOidcUserToDomainModel(updatedUser);
         }, PassportErrorType.REFRESH_TOKEN_ERROR);
     }
 }
@@ -265,12 +768,24 @@ var SendMessage;
 })(SendMessage || (SendMessage = {}));
 var TransactionTypes;
 (function (TransactionTypes) {
+    // TODO: remove this once the naming has been fixed
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     TransactionTypes["CancelOrder"] = "delete:v1/orders";
+    // TODO: remove this once the naming has been fixed
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     TransactionTypes["CreateOrder"] = "post:v1/orders";
+    // TODO: remove this once the naming has been fixed
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     TransactionTypes["CreateTrade"] = "post:v1/trades";
+    // TODO: remove this once the naming has been fixed
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     TransactionTypes["CreateTransfer"] = "post:v1/transfers";
+    // TODO: remove this once the naming has been fixed
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     TransactionTypes["CreateBatchTransfer"] = "post:v2/transfers";
 })(TransactionTypes || (TransactionTypes = {}));
+// TODO: remove this once the naming has been fixed
+// eslint-disable-next-line @typescript-eslint/naming-convention
 const PassportEventType = 'imx_passport_confirmation';
 
 const openPopupCenter = ({ url, title, width, height, }) => {
@@ -290,10 +805,10 @@ const openPopupCenter = ({ url, title, width, height, }) => {
     return newWindow;
 };
 
-const ConfirmationWindowTitle = 'Confirm this transaction';
-const ConfirmationWindowHeight = 380;
-const ConfirmationWindowWidth = 480;
-const ConfirmationWindowClosedPollingDuration = 1000;
+const CONFIRMATION_WINDOW_TITLE = 'Confirm this transaction';
+const CONFIRMATION_WINDOW_HEIGHT = 380;
+const CONFIRMATION_WINDOW_WIDTH = 480;
+const CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION = 1000;
 class ConfirmationScreen {
     config;
     constructor(config) {
@@ -309,12 +824,14 @@ class ConfirmationScreen {
     startTransaction(accessToken, transaction, popupOptions) {
         return new Promise((resolve, reject) => {
             const messageHandler = ({ data, origin }) => {
-                if (origin != this.config.passportDomain ||
-                    data.eventType != PassportEventType) {
+                if (origin !== this.config.passportDomain
+                    || data.eventType !== PassportEventType) {
                     return;
                 }
                 switch (data.messageType) {
                     case ReceiveMessage.CONFIRMATION_WINDOW_READY: {
+                        // TODO: remove once fixed
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
                         this.postMessage(confirmationWindow, accessToken, {
                             messageType: SendMessage.TRANSACTION_START,
                             messageData: transaction,
@@ -336,87 +853,87 @@ class ConfirmationScreen {
             window.addEventListener('message', messageHandler);
             const confirmationWindow = openPopupCenter({
                 url: `${this.config.passportDomain}/transaction-confirmation`,
-                title: ConfirmationWindowTitle,
-                width: popupOptions?.width || ConfirmationWindowWidth,
-                height: popupOptions?.height || ConfirmationWindowHeight,
+                title: CONFIRMATION_WINDOW_TITLE,
+                width: popupOptions?.width || CONFIRMATION_WINDOW_WIDTH,
+                height: popupOptions?.height || CONFIRMATION_WINDOW_HEIGHT,
             });
             // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
-            const timer = setInterval(function () {
+            const timer = setInterval(() => {
                 if (confirmationWindow.closed) {
                     clearInterval(timer);
                     window.removeEventListener('message', messageHandler);
                     resolve({ confirmed: false });
                 }
-            }, ConfirmationWindowClosedPollingDuration);
+            }, CONFIRMATION_WINDOW_CLOSED_POLLING_DURATION);
         });
     }
 }
 
 const ERC721$1 = 'ERC721';
-const transfer = ({ request, transfersApi, starkSigner, user, passportConfig, }) => {
-    return withPassportError(async () => {
-        const transferAmount = request.type === ERC721$1 ? '1' : request.amount;
-        const getSignableTransferRequest = {
-            sender: user.etherKey,
-            token: convertToSignableToken(request),
-            amount: transferAmount,
-            receiver: request.receiver,
-        };
-        const signableResult = await transfersApi.getSignableTransferV1({
-            getSignableTransferRequest,
-        });
-        const confirmationScreen = new ConfirmationScreen(passportConfig);
-        const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
-            transactionType: TransactionTypes.CreateTransfer,
-            transactionData: getSignableTransferRequest,
-        });
-        if (!confirmationResult.confirmed) {
-            throw new Error('Transaction rejected by user');
-        }
-        const signableResultData = signableResult.data;
-        const { payload_hash: payloadHash } = signableResultData;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const senderStarkKey = await starkSigner.getAddress();
-        const transferSigningParams = {
-            sender_stark_key: signableResultData.sender_stark_key || senderStarkKey,
-            sender_vault_id: signableResultData.sender_vault_id,
-            receiver_stark_key: signableResultData.receiver_stark_key,
-            receiver_vault_id: signableResultData.receiver_vault_id,
-            asset_id: signableResultData.asset_id,
-            amount: signableResultData.amount,
-            nonce: signableResultData.nonce,
-            expiration_timestamp: signableResultData.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        const createTransferRequest = {
-            createTransferRequest: transferSigningParams,
-        };
-        const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
-        };
-        const { data: responseData } = await transfersApi.createTransferV1(createTransferRequest, { headers });
-        return {
-            sent_signature: responseData.sent_signature,
-            status: responseData.status?.toString(),
-            time: responseData.time,
-            transfer_id: responseData.transfer_id,
-        };
-    }, PassportErrorType.TRANSFER_ERROR);
-};
+const transfer = ({ request, transfersApi, starkSigner, user, passportConfig,
+// TODO: remove this eslint disable once we have a better solution
+// eslint-disable-next-line max-len
+ }) => withPassportError(async () => {
+    const transferAmount = request.type === ERC721$1 ? '1' : request.amount;
+    const getSignableTransferRequest = {
+        sender: user.etherKey,
+        token: convertToSignableToken(request),
+        amount: transferAmount,
+        receiver: request.receiver,
+    };
+    const signableResult = await transfersApi.getSignableTransferV1({
+        getSignableTransferRequest,
+    });
+    const confirmationScreen = new ConfirmationScreen(passportConfig);
+    const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
+        transactionType: TransactionTypes.CreateTransfer,
+        transactionData: getSignableTransferRequest,
+    });
+    if (!confirmationResult.confirmed) {
+        throw new Error('Transaction rejected by user');
+    }
+    const signableResultData = signableResult.data;
+    const { payload_hash: payloadHash } = signableResultData;
+    const starkSignature = await starkSigner.signMessage(payloadHash);
+    const senderStarkKey = await starkSigner.getAddress();
+    const transferSigningParams = {
+        sender_stark_key: signableResultData.sender_stark_key || senderStarkKey,
+        sender_vault_id: signableResultData.sender_vault_id,
+        receiver_stark_key: signableResultData.receiver_stark_key,
+        receiver_vault_id: signableResultData.receiver_vault_id,
+        asset_id: signableResultData.asset_id,
+        amount: signableResultData.amount,
+        nonce: signableResultData.nonce,
+        expiration_timestamp: signableResultData.expiration_timestamp,
+        stark_signature: starkSignature,
+    };
+    const createTransferRequest = {
+        createTransferRequest: transferSigningParams,
+    };
+    const headers = {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        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 signableRequests = request.map((nftTransfer) => ({
+            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,
@@ -451,7 +968,8 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, pass
             requests,
         };
         const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Authorization: `Bearer ${user.accessToken}`,
         };
         const response = await transfersApi.createTransfer({
             createTransferRequestV2: transferSigningParams,
@@ -508,7 +1026,8 @@ async function createOrder({ starkSigner, user, request, ordersApi, passportConf
             },
         };
         const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Authorization: `Bearer ${user.accessToken}`,
         };
         const createOrderResponse = await ordersApi.createOrder(orderParams, {
             headers,
@@ -537,7 +1056,8 @@ async function cancelOrder({ user, starkSigner, request, ordersApi, passportConf
         const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
         const starkSignature = await starkSigner.signMessage(payloadHash);
         const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Authorization: `Bearer ${user.accessToken}`,
         };
         const cancelOrderResponse = await ordersApi.cancelOrder({
             id: request.order_id.toString(),
@@ -581,7 +1101,8 @@ async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
             stark_signature: starkSignature,
         };
         const headers = {
-            Authorization: 'Bearer ' + user.accessToken,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Authorization: `Bearer ${user.accessToken}`,
         };
         const response = await exchangesApi.createExchangeTransfer({
             id: request.transactionID,
@@ -637,7 +1158,8 @@ async function createTrade({ request, tradesApi, user, starkSigner, passportConf
                 vault_id_sell: signableResultData.vault_id_sell,
             },
         };
-        const headers = { Authorization: 'Bearer ' + user.accessToken };
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const { data: createTradeResponse } = await tradesApi.createTradeV3(tradeParams, {
             headers,
         });
@@ -648,35 +1170,30 @@ async function createTrade({ request, tradesApi, user, starkSigner, passportConf
 class PassportImxProvider {
     user;
     starkSigner;
-    transfersApi;
-    ordersApi;
     passportConfig;
-    exchangesApi;
-    tradesApi;
-    constructor({ user, starkSigner, passportConfig }) {
+    immutableXClient;
+    constructor({ user, starkSigner, passportConfig, immutableXClient, }) {
         this.user = user;
         this.starkSigner = starkSigner;
         this.passportConfig = passportConfig;
-        const apiConfig = new Configuration({
-            basePath: passportConfig.imxApiBasePath,
-        });
-        this.transfersApi = new TransfersApi(apiConfig);
-        this.ordersApi = new OrdersApi(apiConfig);
-        this.exchangesApi = new ExchangesApi(apiConfig);
-        this.tradesApi = new TradesApi(apiConfig);
+        this.immutableXClient = immutableXClient;
     }
     async transfer(request) {
         return transfer({
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
+            transfersApi: this.immutableXClient.transfersApi,
             passportConfig: this.passportConfig,
         });
     }
+    // TODO: Remove once implemented
+    // eslint-disable-next-line class-methods-use-this
     registerOffchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
+    // TODO: Remove once implemented
+    // eslint-disable-next-line class-methods-use-this
     isRegisteredOnchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
@@ -685,7 +1202,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
+            ordersApi: this.immutableXClient.ordersApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -694,7 +1211,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
+            ordersApi: this.immutableXClient.ordersApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -703,7 +1220,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            tradesApi: this.tradesApi,
+            tradesApi: this.immutableXClient.tradesApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -712,7 +1229,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
+            transfersApi: this.immutableXClient.transfersApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -721,17 +1238,21 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            exchangesApi: this.exchangesApi,
+            exchangesApi: this.immutableXClient.exchangeApi,
         });
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    // TODO: Remove once implemented
+    // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
     deposit(deposit) {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    // TODO: Remove once implemented
+    // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
     prepareWithdrawal(request) {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
+    // TODO: Remove once implemented
+    // eslint-disable-next-line class-methods-use-this
     completeWithdrawal(
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     starkPublicKey, 
@@ -768,7 +1289,6 @@ class PassportConfiguration {
     passportDomain;
     magicPublishableApiKey;
     magicProviderId;
-    imxApiBasePath;
     oidcConfiguration;
     baseConfig;
     constructor({ baseConfig, overrides, ...oidcConfiguration }) {
@@ -786,33 +1306,30 @@ class PassportConfiguration {
                 'magicPublishableApiKey',
                 'magicProviderId',
                 'passportDomain',
-                'imxApiBasePath',
             ], 'overrides');
             this.network = overrides.network;
             this.authenticationDomain = overrides.authenticationDomain;
             this.passportDomain = overrides.passportDomain;
             this.magicPublishableApiKey = overrides.magicPublishableApiKey;
             this.magicProviderId = overrides.magicProviderId;
-            this.imxApiBasePath = overrides.imxApiBasePath;
         }
         else {
             switch (baseConfig.environment) {
-                case Environment.SANDBOX: {
-                    this.network = Networks.SANDBOX;
+                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.sandbox.immutable.com';
-                    this.imxApiBasePath = 'https://api.sandbox.x.immutable.com';
+                    this.passportDomain = 'https://passport.immutable.com';
                     break;
                 }
-                case Environment.PRODUCTION: {
-                    this.network = Networks.PRODUCTION;
+                case Environment.SANDBOX:
+                default: {
+                    this.network = Networks.SANDBOX;
                     this.authenticationDomain = 'https://auth.immutable.com';
                     this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
-                    this.passportDomain = 'https://passport.immutable.com';
-                    this.imxApiBasePath = 'https://api.x.immutable.com';
+                    this.passportDomain = 'https://passport.sandbox.immutable.com';
                     break;
                 }
             }
@@ -820,12 +1337,12 @@ class PassportConfiguration {
     }
 }
 
-const getStarkSigner = async (signer) => {
-    return withPassportError(async () => {
-        const privateKey = await generateLegacyStarkPrivateKey(signer);
-        return createStarkSigner(privateKey);
-    }, PassportErrorType.WALLET_CONNECTION_ERROR);
-};
+// TODO: remove this eslint disable once we have a better solution
+// eslint-disable-next-line max-len
+const getStarkSigner = async (signer) => withPassportError(async () => {
+    const privateKey = await generateLegacyStarkPrivateKey(signer);
+    return createStarkSigner(privateKey);
+}, PassportErrorType.WALLET_CONNECTION_ERROR);
 
 async function registerPassport({ ethSigner, starkSigner, usersApi }, authorization) {
     return withPassportError(async () => {
@@ -841,7 +1358,7 @@ async function registerPassport({ ethSigner, starkSigner, usersApi }, authorizat
         const ethSignature = await signRaw(signableMessage, ethSigner);
         const starkSignature = await starkSigner.signMessage(payloadHash);
         const response = await usersApi.registerPassportUser({
-            authorization: `Bearer ` + authorization,
+            authorization: `Bearer ${authorization}`,
             registerPassportUserRequest: {
                 eth_signature: ethSignature,
                 ether_key: userAddress,
@@ -853,15 +1370,20 @@ async function registerPassport({ ethSigner, starkSigner, usersApi }, authorizat
     }, PassportErrorType.USER_REGISTRATION_ERROR);
 }
 
+// TODO: Remove this once the dependency has been added
 class Passport {
     authManager;
     magicAdapter;
     config;
+    immutableXClient;
     constructor(passportModuleConfiguration) {
-        const passportConfiguration = new PassportConfiguration(passportModuleConfiguration);
-        this.config = passportConfiguration;
+        this.config = new PassportConfiguration(passportModuleConfiguration);
         this.authManager = new AuthManager(this.config);
         this.magicAdapter = new MagicAdapter(this.config);
+        this.immutableXClient = passportModuleConfiguration.overrides?.immutableXClient
+            || new ImmutableXClient({
+                baseConfig: passportModuleConfiguration.baseConfig,
+            });
     }
     async getImxProvider(user) {
         if (!user || !user.idToken) {
@@ -876,6 +1398,7 @@ class Passport {
                 user: updatedUser,
                 starkSigner,
                 passportConfig: this.config,
+                immutableXClient: this.immutableXClient,
             });
         }
         const userWithEtherKey = user;
@@ -883,6 +1406,7 @@ class Passport {
             user: userWithEtherKey,
             starkSigner,
             passportConfig: this.config,
+            immutableXClient: this.immutableXClient,
         });
     }
     async connectImxSilent() {
@@ -915,14 +1439,10 @@ class Passport {
         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,
+            usersApi: this.immutableXClient.usersApi,
         }, jwt);
         const updatedUser = await this.authManager.requestRefreshTokenAfterRegistration();
         if (!updatedUser) {