@imtbl/sdk 0.27.9 → 0.27.10

package/dist/passport.js

@@ -2072,7 +2072,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.27.9' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.27.10' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -2128,7 +2128,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.27.9',
+    sdkVersion: 'ts-immutable-sdk-0.27.10',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -6591,6 +6591,7 @@ var PassportErrorType;
     PassportErrorType["SILENT_LOGIN_ERROR"] = "SILENT_LOGIN_ERROR";
     PassportErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
     PassportErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
+    PassportErrorType["USER_NOT_REGISTERED_ERROR"] = "USER_NOT_REGISTERED_ERROR";
     PassportErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
     PassportErrorType["TRANSFER_ERROR"] = "TRANSFER_ERROR";
     PassportErrorType["CREATE_ORDER_ERROR"] = "CREATE_ORDER_ERROR";
@@ -6740,6 +6741,10 @@ class AuthManager {
     config;
     deviceCredentialsManager;
     logoutMode;
+    /**
+     * Promise that is used to prevent multiple concurrent calls to the refresh token endpoint.
+     */
+    refreshingPromise = null;
     constructor(config) {
         this.config = config;
         this.userManager = new UserManager(getAuthConfiguration(config));
@@ -6984,32 +6989,52 @@ class AuthManager {
      * @param forceRefresh If set to true, force an HTTP call to the OIDC server's authorization endpoint. This call will
      * throw an error if there's no refresh token.
      */
-    async getWebUser({ forceRefresh = false }) {
+    async getAuthenticatedUser({ forceRefresh = false }) {
         if (forceRefresh) {
-            const newOidcUser = await this.userManager.signinSilent();
-            return newOidcUser ? AuthManager.mapOidcUserToDomainModel(newOidcUser) : null;
+            return this.refreshTokenAndUpdatePromise();
         }
         const oidcUser = await this.userManager.getUser();
         if (!oidcUser)
             return null;
-        const tokenExpired = isTokenExpired(oidcUser);
-        if (!tokenExpired) {
+        if (!isTokenExpired(oidcUser)) {
             return AuthManager.mapOidcUserToDomainModel(oidcUser);
         }
         if (oidcUser.refresh_token) {
-            const newOidcUser = await this.userManager.signinSilent();
-            if (newOidcUser) {
-                return AuthManager.mapOidcUserToDomainModel(newOidcUser);
-            }
+            return this.refreshTokenAndUpdatePromise();
         }
         return null;
     }
+    /**
+     * Refreshes the token and returns the user.
+     * If the token is already being refreshed, returns the existing promise.
+     */
+    async refreshTokenAndUpdatePromise() {
+        if (this.refreshingPromise)
+            return this.refreshingPromise;
+        // eslint-disable-next-line no-async-promise-executor
+        this.refreshingPromise = new Promise(async (resolve, reject) => {
+            try {
+                const newOidcUser = await this.userManager.signinSilent();
+                if (newOidcUser) {
+                    resolve(AuthManager.mapOidcUserToDomainModel(newOidcUser));
+                    return;
+                }
+                resolve(null);
+            }
+            catch (err) {
+                reject(err);
+            }
+            finally {
+                this.refreshingPromise = null; // Reset the promise after completion
+            }
+        });
+        return this.refreshingPromise;
+    }
     async getUser({ forceRefresh } = { forceRefresh: false }) {
         return withPassportError(async () => {
-            const user = await this.getWebUser({ forceRefresh });
-            if (user) {
+            const user = await this.getAuthenticatedUser({ forceRefresh });
+            if (user)
                 return user;
-            }
             const deviceToken = this.deviceCredentialsManager.getCredentials();
             if (deviceToken) {
                 return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
@@ -7036,14 +7061,16 @@ class MagicAdapter {
     magicClient;
     constructor(config) {
         this.config = config;
-        this.magicClient = new Magic(this.config.magicPublishableApiKey, {
-            extensions: [new OpenIdExtension()],
-            network: config.network,
-        });
-        this.magicClient.preload();
+        if (window) {
+            this.magicClient = this.initMagicClient();
+            this.magicClient.preload();
+        }
     }
     async login(idToken) {
         return withPassportError(async () => {
+            if (!this.magicClient) {
+                this.magicClient = this.initMagicClient();
+            }
             await this.magicClient.openid.loginWithOIDC({
                 jwt: idToken,
                 providerId: this.config.magicProviderId,
@@ -7052,10 +7079,16 @@ class MagicAdapter {
         }, PassportErrorType.WALLET_CONNECTION_ERROR);
     }
     async logout() {
-        if (this.magicClient.user) {
+        if (this.magicClient?.user) {
             await this.magicClient.user.logout();
         }
     }
+    initMagicClient() {
+        return new Magic(this.config.magicPublishableApiKey, {
+            extensions: [new OpenIdExtension()],
+            network: this.config.network,
+        });
+    }
 }
 
 const getStarkSigner = async (signer) => withPassportError(async () => {
@@ -7142,16 +7175,13 @@ class GuardianClient {
     transactionAPI;
     messageAPI;
     confirmationScreen;
-    // TODO: ID-977, make this rollup agnostic
-    imxEtherAddress;
     crossSdkBridgeEnabled;
-    constructor({ accessToken, confirmationScreen, imxEtherAddress, config, }) {
-        const guardianConfiguration = new Configuration({ accessToken, basePath: config.imxPublicApiDomain });
+    constructor({ confirmationScreen, config }) {
+        const guardianConfiguration = new Configuration({ basePath: config.imxPublicApiDomain });
         this.confirmationScreen = confirmationScreen;
-        this.transactionAPI = new TransactionsApi(new Configuration(guardianConfiguration));
-        this.imxEtherAddress = imxEtherAddress;
         this.crossSdkBridgeEnabled = config.crossSdkBridgeEnabled;
         this.messageAPI = new MessagesApi(guardianConfiguration);
+        this.transactionAPI = new TransactionsApi(guardianConfiguration);
     }
     /**
      * Open confirmation screen and close it automatically if the
@@ -7175,29 +7205,30 @@ class GuardianClient {
     withDefaultConfirmationScreenTask(task) {
         return this.withConfirmationScreenTask()(task);
     }
-    async validate({ payloadHash }) {
+    async evaluateImxTransaction({ payloadHash, user }) {
         const finallyFn = () => {
             this.confirmationScreen.closeWindow();
         };
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const transactionRes = await retryWithDelay(async () => this.transactionAPI.getTransactionByID({
             transactionID: payloadHash,
             chainType: 'starkex',
-        }), { finallyFn });
+        }, { headers }), { finallyFn });
         if (!transactionRes.data.id) {
             throw new Error("Transaction doesn't exists");
         }
-        const evaluateStarkexRes = await this.transactionAPI.evaluateTransaction({
+        const evaluateImxRes = await this.transactionAPI.evaluateTransaction({
             id: payloadHash,
             transactionEvaluationRequest: {
                 chainType: 'starkex',
             },
-        });
-        const { confirmationRequired } = evaluateStarkexRes.data;
+        }, { headers });
+        const { confirmationRequired } = evaluateImxRes.data;
         if (confirmationRequired) {
             if (this.crossSdkBridgeEnabled) {
                 throw new Error(transactionRejectedCrossSdkBridgeError);
             }
-            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, user.imx.ethAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
             if (!confirmationResult.confirmed) {
                 throw new Error('Transaction rejected by user');
             }
@@ -7241,7 +7272,7 @@ class GuardianClient {
             throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
         }
         if (confirmationRequired && !!transactionId) {
-            const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, this.imxEtherAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, user.zkEvm.ethAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
             if (!confirmationResult.confirmed) {
                 throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Transaction rejected by user');
             }
@@ -7337,10 +7368,7 @@ async function createOrder({ starkSigner, user, request, ordersApi, guardianClie
         const { ethAddress } = user.imx;
         const amountSell = request.sell.type === ERC721$1 ? '1' : request.sell.amount;
         const amountBuy = request.buy.type === ERC721$1 ? '1' : request.buy.amount;
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const getSignableOrderRequestV3 = {
             user: ethAddress,
             amount_buy: amountBuy,
@@ -7354,7 +7382,8 @@ async function createOrder({ starkSigner, user, request, ordersApi, guardianClie
         const getSignableOrderResponse = await ordersApi.getSignableOrder({
             getSignableOrderRequestV3,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: getSignableOrderResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableOrderResponse.data;
@@ -7396,7 +7425,8 @@ async function cancelOrder({ user, starkSigner, request, ordersApi, guardianClie
         const getSignableCancelOrderResponse = await ordersApi.getSignableCancelOrderV3({
             getSignableCancelOrderRequest,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: getSignableCancelOrderResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
@@ -7459,7 +7489,8 @@ async function createTrade({ request, tradesApi, user, starkSigner, guardianClie
         const getSignableTradeResponse = await tradesApi.getSignableTrade({
             getSignableTradeRequest,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: getSignableTradeResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableTradeResponse.data;
@@ -7506,7 +7537,8 @@ async function transfer({ request, transfersApi, starkSigner, user, guardianClie
         const signableResult = await transfersApi.getSignableTransferV1({
             getSignableTransferRequest,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: signableResult.data.payload_hash,
         });
         const signableResultData = signableResult.data;
@@ -7553,14 +7585,12 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
             sender_ether_key: ethAddress,
             signable_requests: signableRequests,
         };
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
         const signableResult = await transfersApi.getSignableTransfer({
             getSignableTransferRequestV2,
         }, { headers });
-        await guardianClient.validate({
+        await guardianClient.evaluateImxTransaction({
+            user,
             payloadHash: signableResult.data.signable_responses[0]?.payload_hash,
         });
         const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
@@ -7590,39 +7620,40 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
 }
 
 class PassportImxProvider {
-    user;
+    authManager;
     starkSigner;
     immutableXClient;
-    confirmationScreen;
     guardianClient;
-    constructor({ user, starkSigner, immutableXClient, confirmationScreen, config, passportEventEmitter, }) {
-        this.user = user;
+    constructor({ authManager, starkSigner, immutableXClient, confirmationScreen, config, passportEventEmitter, }) {
+        this.authManager = authManager;
         this.starkSigner = starkSigner;
         this.immutableXClient = immutableXClient;
-        this.confirmationScreen = confirmationScreen;
         this.guardianClient = new GuardianClient({
-            accessToken: user.accessToken,
             confirmationScreen,
-            imxEtherAddress: user.imx.ethAddress,
             config,
         });
         passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
     }
     handleLogout = () => {
-        this.user = undefined;
         this.starkSigner = undefined;
     };
-    checkIsLoggedIn() {
-        if (this.user === undefined || this.starkSigner === undefined) {
+    async getAuthenticatedUserSigner() {
+        const user = await this.authManager.getUser();
+        if (!user || this.starkSigner === undefined) {
             throw new PassportError('User has been logged out', PassportErrorType.NOT_LOGGED_IN_ERROR);
         }
+        const isUserImx = (oidcUser) => oidcUser?.imx !== undefined;
+        if (!isUserImx(user)) {
+            throw new PassportError('User has not been registered with StarkEx', PassportErrorType.USER_NOT_REGISTERED_ERROR);
+        }
+        return { user, starkSigner: this.starkSigner };
     }
     async transfer(request) {
-        this.checkIsLoggedIn();
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return transfer({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             transfersApi: this.immutableXClient.transfersApi,
             guardianClient: this.guardianClient,
         });
@@ -7637,52 +7668,52 @@ class PassportImxProvider {
     isRegisteredOnchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    createOrder(request) {
-        this.checkIsLoggedIn();
+    async createOrder(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return createOrder({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             ordersApi: this.immutableXClient.ordersApi,
             guardianClient: this.guardianClient,
         });
     }
-    cancelOrder(request) {
-        this.checkIsLoggedIn();
+    async cancelOrder(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return cancelOrder({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             ordersApi: this.immutableXClient.ordersApi,
             guardianClient: this.guardianClient,
         });
     }
-    createTrade(request) {
-        this.checkIsLoggedIn();
+    async createTrade(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return createTrade({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             tradesApi: this.immutableXClient.tradesApi,
             guardianClient: this.guardianClient,
         });
     }
-    batchNftTransfer(request) {
-        this.checkIsLoggedIn();
+    async batchNftTransfer(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return batchNftTransfer({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             transfersApi: this.immutableXClient.transfersApi,
             guardianClient: this.guardianClient,
         });
     }
-    exchangeTransfer(request) {
-        this.checkIsLoggedIn();
+    async exchangeTransfer(request) {
+        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
         return exchangeTransfer({
             request,
-            user: this.user,
-            starkSigner: this.starkSigner,
+            user,
+            starkSigner,
             exchangesApi: this.immutableXClient.exchangeApi,
         });
     }
@@ -7705,9 +7736,9 @@ class PassportImxProvider {
     token) {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
-    getAddress() {
-        this.checkIsLoggedIn();
-        return Promise.resolve(this.user.imx.ethAddress);
+    async getAddress() {
+        const { user } = await this.getAuthenticatedUserSigner();
+        return Promise.resolve(user.imx.ethAddress);
     }
 }
 
@@ -7761,9 +7792,9 @@ class PassportImxProviderFactory {
         const ethSigner = web3Provider.getSigner();
         const starkSigner = await getStarkSigner(ethSigner);
         if (!user.imx?.ethAddress) {
-            const userImx = await this.registerStarkEx(ethSigner, starkSigner, user.accessToken);
+            await this.registerStarkEx(ethSigner, starkSigner, user.accessToken);
             return new PassportImxProvider({
-                user: userImx,
+                authManager: this.authManager,
                 starkSigner,
                 immutableXClient: this.immutableXClient,
                 confirmationScreen: this.confirmationScreen,
@@ -7772,7 +7803,7 @@ class PassportImxProviderFactory {
             });
         }
         return new PassportImxProvider({
-            user: user,
+            authManager: this.authManager,
             starkSigner,
             immutableXClient: this.immutableXClient,
             confirmationScreen: this.confirmationScreen,
@@ -8517,9 +8548,7 @@ class ZkEvmProvider {
                     user: this.user,
                 });
                 this.guardianClient = new GuardianClient({
-                    accessToken: this.user.accessToken,
                     confirmationScreen: this.confirmationScreen,
-                    imxEtherAddress: this.user.zkEvm.ethAddress,
                     config: this.config,
                 });
                 this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.user.zkEvm.ethAddress]);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "0.27.9",
+  "version": "0.27.10",
   "author": "Immutable",
   "browser": "./dist/index.browser.js",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",