@imtbl/sdk 0.1.3 → 0.1.4-alpha

package/dist/passport.js

@@ -1,10 +1,10 @@
-import { Configuration, UsersApi, TransfersApi, OrdersApi, ExchangesApi, TradesApi, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 import { UserManager } from 'oidc-client-ts';
 import { ethers } from 'ethers';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
+import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 
 // used to sign message with L1 keys. Used for registration
 function serializeEthSignature(sig) {
@@ -73,6 +73,506 @@ var Environment;
     Environment["SANDBOX"] = "sandbox";
 })(Environment || (Environment = {}));
 
+// Set `sdkVersion` on config
+const PRODUCTION = () => {
+    return Config.createConfig({
+        basePath: 'https://api.x.immutable.com',
+        chainID: 1,
+        coreContractAddress: '0x5FDCCA53617f4d2b9134B29090C87D01058e27e9',
+        registrationContractAddress: '0x72a06bf2a1CE5e39cBA06c0CAb824960B587d64c',
+        sdkVersion: 'ts-immutable-sdk-0.1.4-alpha',
+    });
+};
+// Set `sdkVersion` on config
+const SANDBOX = () => {
+    return Config.createConfig({
+        basePath: 'https://api.sandbox.x.immutable.com',
+        chainID: 5,
+        coreContractAddress: '0x7917eDb51ecD6CdB3F9854c3cc593F33de10c623',
+        registrationContractAddress: '0x1C97Ada273C9A52253f463042f29117090Cd7D83',
+        sdkVersion: 'ts-immutable-sdk-0.1.4-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;
+                }
+            }
+        }
+    }
+}
+
+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);
+    }
+}
+
 var PassportErrorType;
 (function (PassportErrorType) {
     PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
@@ -648,29 +1148,20 @@ 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,
         });
     }
@@ -685,7 +1176,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
+            ordersApi: this.immutableXClient.ordersApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -694,7 +1185,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            ordersApi: this.ordersApi,
+            ordersApi: this.immutableXClient.ordersApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -703,7 +1194,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            tradesApi: this.tradesApi,
+            tradesApi: this.immutableXClient.tradesApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -712,7 +1203,7 @@ class PassportImxProvider {
             request,
             user: this.user,
             starkSigner: this.starkSigner,
-            transfersApi: this.transfersApi,
+            transfersApi: this.immutableXClient.transfersApi,
             passportConfig: this.passportConfig,
         });
     }
@@ -721,7 +1212,7 @@ 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
@@ -768,7 +1259,6 @@ class PassportConfiguration {
     passportDomain;
     magicPublishableApiKey;
     magicProviderId;
-    imxApiBasePath;
     oidcConfiguration;
     baseConfig;
     constructor({ baseConfig, overrides, ...oidcConfiguration }) {
@@ -786,14 +1276,12 @@ 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) {
@@ -803,7 +1291,6 @@ class PassportConfiguration {
                     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: {
@@ -812,7 +1299,6 @@ class PassportConfiguration {
                     this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
                     this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
                     this.passportDomain = 'https://passport.immutable.com';
-                    this.imxApiBasePath = 'https://api.x.immutable.com';
                     break;
                 }
             }
@@ -857,11 +1343,16 @@ 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 +1367,7 @@ class Passport {
                 user: updatedUser,
                 starkSigner,
                 passportConfig: this.config,
+                immutableXClient: this.immutableXClient,
             });
         }
         const userWithEtherKey = user;
@@ -883,6 +1375,7 @@ class Passport {
             user: userWithEtherKey,
             starkSigner,
             passportConfig: this.config,
+            immutableXClient: this.immutableXClient,
         });
     }
     async connectImxSilent() {
@@ -915,14 +1408,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) {