@imtbl/sdk 0.32.0 → 0.34.0

package/dist/orderbook.js

@@ -429,7 +429,7 @@ class OrdersService {
      * @returns ListListingsResult OK response.
      * @throws ApiError
      */
-    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }) {
+    listListings({ chainName, status, sellItemContractAddress, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }) {
         return this.httpRequest.request({
             method: 'GET',
             url: '/v1/chains/{chain_name}/orders/listings',
@@ -440,6 +440,8 @@ class OrdersService {
                 'status': status,
                 'sell_item_contract_address': sellItemContractAddress,
                 'buy_item_contract_address': buyItemContractAddress,
+                'account_address': accountAddress,
+                'sell_item_metadata_id': sellItemMetadataId,
                 'sell_item_token_id': sellItemTokenId,
                 'from_updated_at': fromUpdatedAt,
                 'page_size': pageSize,

package/dist/passport.d.ts

@@ -10203,7 +10203,7 @@ declare enum Networks {
 }
 interface OidcConfiguration {
     clientId: string;
-    logoutRedirectUri: string;
+    logoutRedirectUri?: string;
     logoutMode?: 'redirect' | 'silent';
     redirectUri: string;
     scope?: string;
@@ -10337,14 +10337,8 @@ declare class Passport {
      */
     connectImxSilent(): Promise<IMXProvider | null>;
     connectImx(): Promise<IMXProvider>;
-    connectImxDeviceFlow(deviceCode: string, interval: number, timeoutMs?: number): Promise<IMXProvider | null>;
     getPKCEAuthorizationUrl(): string;
     connectImxPKCEFlow(authorizationCode: string, state: string): Promise<IMXProvider | null>;
-    /**
-     * @returns {boolean} the stored device flow credentials if they exist
-     */
-    checkStoredDeviceFlowCredentials(): DeviceTokenResponse | null;
-    connectImxWithCredentials(tokenResponse: DeviceTokenResponse): Promise<IMXProvider | null>;
     connectEvm(): Provider;
     /**
      *
@@ -10357,17 +10351,23 @@ declare class Passport {
     login(options?: {
         useCachedSession: boolean;
     }): Promise<UserProfile | null>;
-    loginWithDeviceFlow(): Promise<DeviceConnectResponse>;
     loginCallback(): Promise<void>;
+    loginWithDeviceFlow(): Promise<DeviceConnectResponse>;
+    loginWithDeviceFlowCallback(deviceCode: string, interval: number, timeoutMs?: number): Promise<UserProfile>;
     logout(): Promise<void>;
+    /**
+     * Logs the user out of Passport when using device flow authentication.
+     *
+     * @returns {Promise<string>} The device flow end session endpoint. Consumers are responsible for
+     * opening this URL in the same browser that was used to log the user in.
+     */
+    logoutDeviceFlow(): Promise<string>;
     /**
      * This method should only be called from the logout redirect uri
      * when logout mode is 'silent'.
      */
     logoutSilentCallback(url: string): Promise<void>;
-    logoutDeviceFlow(): Promise<void>;
     getUserInfo(): Promise<UserProfile | undefined>;
-    getUserInfoDeviceFlow(): Promise<UserProfile | undefined>;
     getIdToken(): Promise<string | undefined>;
     getAccessToken(): Promise<string | undefined>;
     getLinkedAddresses(): Promise<string[]>;

package/dist/passport.js

@@ -1,6 +1,6 @@
 import globalAxios$1, { isAxiosError as isAxiosError$1 } from 'axios';
 import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
-import { UserManager, InMemoryWebStorage, WebStorageStateStore } from 'oidc-client-ts';
+import { UserManager, User, InMemoryWebStorage, WebStorageStateStore } from 'oidc-client-ts';
 import jwt_decode from 'jwt-decode';
 import * as crypto from 'crypto';
 import { Magic } from 'magic-sdk';
@@ -2191,7 +2191,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.32.0' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.34.0' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -2247,7 +2247,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.32.0',
+    sdkVersion: 'ts-immutable-sdk-0.34.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -6780,26 +6780,10 @@ var ChainName;
     ChainName["IMTBL_ZKEVM_MAINNET"] = "Immutable zkEVM";
 })(ChainName || (ChainName = {}));
 
-const keyCrendentials = 'passport_credentials';
 const KEY_PKCE_STATE = 'pkce_state';
 const KEY_PKCE_VERIFIER = 'pkce_verifier';
 const validCredentialsMinTtlSec = 3600; // 1 hour
 class DeviceCredentialsManager {
-    saveCredentials(tokenResponse) {
-        if (this.areValid(tokenResponse)) {
-            localStorage.setItem(keyCrendentials, JSON.stringify(tokenResponse));
-        }
-        else {
-            throw Error('Invalid credentials.');
-        }
-    }
-    getCredentials() {
-        const credentialsJson = localStorage.getItem(keyCrendentials);
-        if (credentialsJson) {
-            return JSON.parse(credentialsJson);
-        }
-        return null;
-    }
     areValid(tokenResponse) {
         if (tokenResponse) {
             const accessTokenValid = this.isTokenValid(tokenResponse.access_token);
@@ -6819,9 +6803,6 @@ class DeviceCredentialsManager {
             return false;
         }
     }
-    clearCredentials() {
-        localStorage.removeItem(keyCrendentials);
-    }
     savePKCEData(data) {
         localStorage.setItem(KEY_PKCE_STATE, data.state);
         localStorage.setItem(KEY_PKCE_VERIFIER, data.verifier);
@@ -6857,9 +6838,14 @@ const formUrlEncodedHeader = {
         'Content-Type': 'application/x-www-form-urlencoded',
     },
 };
-const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
+const getAuthConfiguration = (config) => {
+    const { authenticationDomain, oidcConfiguration } = config;
     const store = typeof window !== 'undefined' ? window.localStorage : new InMemoryWebStorage();
     const userStore = new WebStorageStateStore({ store });
+    let endSessionEndpoint = `${authenticationDomain}/v2/logout?client_id=${oidcConfiguration.clientId}`;
+    if (oidcConfiguration.logoutRedirectUri) {
+        endSessionEndpoint += `&returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}`;
+    }
     const baseConfiguration = {
         authority: authenticationDomain,
         redirect_uri: oidcConfiguration.redirectUri,
@@ -6869,9 +6855,7 @@ 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: endSessionEndpoint,
         },
         mergeClaims: true,
         loadUserInfo: true,
@@ -6890,6 +6874,15 @@ function wait$1(ms) {
         setTimeout(resolve, ms);
     });
 }
+function base64URLEncode(str) {
+    return str.toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+}
+function sha256(buffer) {
+    return crypto.createHash('sha256').update(buffer).digest();
+}
 class AuthManager {
     userManager;
     config;
@@ -6933,32 +6926,24 @@ class AuthManager {
         }
         return user;
     };
-    static mapDeviceTokenResponseToDomainUserModel = (tokenResponse) => {
+    static mapDeviceTokenResponseToOidcUser = (tokenResponse) => {
         const idTokenPayload = jwt_decode(tokenResponse.id_token);
-        const user = {
-            idToken: tokenResponse.id_token,
-            accessToken: tokenResponse.access_token,
-            refreshToken: tokenResponse.refresh_token,
+        return new User({
+            id_token: tokenResponse.id_token,
+            access_token: tokenResponse.access_token,
+            refresh_token: tokenResponse.refresh_token,
+            token_type: tokenResponse.token_type,
             profile: {
                 sub: idTokenPayload.sub,
+                iss: idTokenPayload.iss,
+                aud: idTokenPayload.aud,
+                exp: idTokenPayload.exp,
+                iat: idTokenPayload.iat,
                 email: idTokenPayload.email,
                 nickname: idTokenPayload.nickname,
+                passport: idTokenPayload.passport,
             },
-        };
-        if (idTokenPayload?.passport?.imx_eth_address) {
-            user.imx = {
-                ethAddress: idTokenPayload.passport.imx_eth_address,
-                starkAddress: idTokenPayload.passport.imx_stark_address,
-                userAdminAddress: idTokenPayload.passport.imx_user_admin_address,
-            };
-        }
-        if (idTokenPayload?.passport?.zkevm_eth_address) {
-            user.zkEvm = {
-                ethAddress: idTokenPayload?.passport?.zkevm_eth_address,
-                userAdminAddress: idTokenPayload?.passport?.zkevm_user_admin_address,
-            };
-        }
-        return user;
+        });
     };
     async login() {
         return withPassportError(async () => {
@@ -6988,7 +6973,7 @@ class AuthManager {
         }, PassportErrorType.AUTHENTICATION_ERROR);
     }
     /* eslint-disable no-await-in-loop */
-    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
+    async loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
         return withPassportError(async () => {
             const startTime = Date.now();
             const loopCondition = true;
@@ -6999,8 +6984,9 @@ class AuthManager {
                 await wait$1(interval * 1000);
                 try {
                     const tokenResponse = await this.getDeviceFlowToken(deviceCode);
-                    const user = AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
-                    this.deviceCredentialsManager.saveCredentials(tokenResponse);
+                    const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
+                    const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
+                    await this.userManager.storeUser(oidcUser);
                     return user;
                 }
                 catch (error) {
@@ -7036,20 +7022,11 @@ class AuthManager {
         }, formUrlEncodedHeader);
         return response.data;
     }
-    static base64URLEncode(str) {
-        return str.toString('base64')
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=/g, '');
-    }
-    static sha256(buffer) {
-        return crypto.createHash('sha256').update(buffer).digest();
-    }
     getPKCEAuthorizationUrl() {
-        const verifier = AuthManager.base64URLEncode(crypto.randomBytes(32));
-        const challenge = AuthManager.base64URLEncode(AuthManager.sha256(verifier));
+        const verifier = base64URLEncode(crypto.randomBytes(32));
+        const challenge = base64URLEncode(sha256(verifier));
         // https://auth0.com/docs/secure/attack-protection/state-parameters
-        const state = AuthManager.base64URLEncode(crypto.randomBytes(32));
+        const state = base64URLEncode(crypto.randomBytes(32));
         this.deviceCredentialsManager.savePKCEData({ state, verifier });
         return `${this.config.authenticationDomain}/authorize?`
             + 'response_type=code'
@@ -7071,8 +7048,9 @@ class AuthManager {
                 throw new Error('Provided state does not match stored state');
             }
             const tokenResponse = await this.getPKCEToken(authorizationCode, pkceData.verifier);
-            const user = AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
-            this.deviceCredentialsManager.saveCredentials(tokenResponse);
+            const oidcUser = AuthManager.mapDeviceTokenResponseToOidcUser(tokenResponse);
+            const user = AuthManager.mapOidcUserToDomainModel(oidcUser);
+            await this.userManager.storeUser(oidcUser);
             return user;
         }, PassportErrorType.AUTHENTICATION_ERROR);
     }
@@ -7086,31 +7064,6 @@ class AuthManager {
         }, formUrlEncodedHeader);
         return response.data;
     }
-    async connectImxWithCredentials(tokenResponse) {
-        return withPassportError(async () => {
-            if (this.deviceCredentialsManager.areValid(tokenResponse)) {
-                // Credentials exist and are still valid
-                return AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
-            }
-            const refreshToken = tokenResponse?.refresh_token ?? null;
-            if (refreshToken) {
-                // Token is no longer valid, but refresh token can be used to a new one
-                const user = await this.refreshToken(refreshToken);
-                return user;
-            }
-            return null;
-        }, PassportErrorType.AUTHENTICATION_ERROR);
-    }
-    async refreshToken(refreshToken) {
-        const response = await globalAxios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
-            client_id: this.config.oidcConfiguration.clientId,
-            grant_type: 'refresh_token',
-            refresh_token: refreshToken,
-        }, formUrlEncodedHeader);
-        const newTokenResponse = response.data;
-        this.deviceCredentialsManager.saveCredentials(newTokenResponse);
-        return AuthManager.mapDeviceTokenResponseToDomainUserModel(newTokenResponse);
-    }
     async logout() {
         return withPassportError(async () => {
             if (this.logoutMode === 'silent') {
@@ -7119,29 +7072,20 @@ class AuthManager {
             return this.userManager.signoutRedirect();
         }, PassportErrorType.LOGOUT_ERROR);
     }
-    async logoutSilentCallback(url) {
-        return this.userManager.signoutSilentCallback(url);
+    async removeUser() {
+        return this.userManager.removeUser();
     }
-    async logoutDeviceFlow() {
-        return withPassportError(async () => {
-            this.deviceCredentialsManager.clearCredentials();
-        }, PassportErrorType.LOGOUT_ERROR);
-    }
-    /**
-     * Get the user from the cache or refresh the token if it's expired.
-     * return null if there's no refresh token.
-     */
-    async getAuthenticatedUser() {
-        const oidcUser = await this.userManager.getUser();
-        if (!oidcUser)
-            return null;
-        if (!isTokenExpired(oidcUser)) {
-            return AuthManager.mapOidcUserToDomainModel(oidcUser);
-        }
-        if (oidcUser.refresh_token) {
-            return this.refreshTokenAndUpdatePromise();
+    getDeviceFlowEndSessionEndpoint() {
+        const { authenticationDomain, oidcConfiguration } = this.config;
+        let endSessionEndpoint = `${authenticationDomain}/v2/logout`;
+        if (oidcConfiguration.logoutRedirectUri) {
+            endSessionEndpoint += `?client_id=${oidcConfiguration.clientId}`
+                + `&returnTo=${encodeURIComponent(oidcConfiguration.logoutRedirectUri)}`;
         }
-        return null;
+        return endSessionEndpoint;
+    }
+    async logoutSilentCallback(url) {
+        return this.userManager.signoutSilentCallback(url);
     }
     async forceUserRefresh() {
         return this.refreshTokenAndUpdatePromise();
@@ -7156,25 +7100,10 @@ class AuthManager {
         // eslint-disable-next-line no-async-promise-executor
         this.refreshingPromise = new Promise(async (resolve, reject) => {
             try {
-                if (this.config.crossSdkBridgeEnabled) {
-                    const tokenResponse = this.checkStoredDeviceFlowCredentials();
-                    if (tokenResponse) {
-                        const refreshToken = tokenResponse?.refresh_token ?? null;
-                        if (refreshToken) {
-                            const newUser = await this.refreshToken(refreshToken);
-                            if (newUser) {
-                                resolve(newUser);
-                                return;
-                            }
-                        }
-                    }
-                }
-                else {
-                    const newOidcUser = await this.userManager.signinSilent();
-                    if (newOidcUser) {
-                        resolve(AuthManager.mapOidcUserToDomainModel(newOidcUser));
-                        return;
-                    }
+                const newOidcUser = await this.userManager.signinSilent();
+                if (newOidcUser) {
+                    resolve(AuthManager.mapOidcUserToDomainModel(newOidcUser));
+                    return;
                 }
                 resolve(null);
             }
@@ -7187,30 +7116,24 @@ class AuthManager {
         });
         return this.refreshingPromise;
     }
+    /**
+     * Get the user from the cache or refresh the token if it's expired.
+     * return null if there's no refresh token.
+     */
     async getUser() {
         return withPassportError(async () => {
-            const user = await this.getAuthenticatedUser();
-            if (user)
-                return user;
-            const deviceToken = this.deviceCredentialsManager.getCredentials();
-            if (deviceToken) {
-                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            const oidcUser = await this.userManager.getUser();
+            if (!oidcUser)
+                return null;
+            if (!isTokenExpired(oidcUser)) {
+                return AuthManager.mapOidcUserToDomainModel(oidcUser);
             }
-            return null;
-        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
-    }
-    async getUserDeviceFlow() {
-        return withPassportError(async () => {
-            const deviceToken = this.deviceCredentialsManager.getCredentials();
-            if (deviceToken) {
-                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            if (oidcUser.refresh_token) {
+                return this.refreshTokenAndUpdatePromise();
             }
             return null;
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
     }
-    checkStoredDeviceFlowCredentials() {
-        return this.deviceCredentialsManager.getCredentials();
-    }
 }
 
 const lazyLoad = (promiseToAwait, initialiseFunction) => promiseToAwait().then(initialiseFunction);
@@ -8045,21 +7968,10 @@ class PassportImxProviderFactory {
         }
         return this.createProviderInstance(user);
     }
-    async getProviderWithDeviceFlow(deviceCode, interval, timeoutMs) {
-        const user = await this.authManager.connectImxDeviceFlow(deviceCode, interval, timeoutMs);
-        return this.createProviderInstance(user);
-    }
     async getProviderWithPKCEFlow(authorizationCode, state) {
         const user = await this.authManager.connectImxPKCEFlow(authorizationCode, state);
         return this.createProviderInstance(user);
     }
-    async getProviderWithCredentials(tokenResponse) {
-        const user = await this.authManager.connectImxWithCredentials(tokenResponse);
-        if (!user) {
-            return null;
-        }
-        return this.createProviderInstance(user);
-    }
     async createProviderInstance(user) {
         if (!user.idToken) {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
@@ -8103,7 +8015,6 @@ class PassportConfiguration {
     constructor({ baseConfig, overrides, crossSdkBridgeEnabled, ...oidcConfiguration }) {
         validateConfiguration(oidcConfiguration, [
             'clientId',
-            'logoutRedirectUri',
             'redirectUri',
         ]);
         this.oidcConfiguration = oidcConfiguration;
@@ -8578,7 +8489,7 @@ const CHAIN_NAME_MAP = new Map([
 ]);
 
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-async function registerZkEvmUser({ authManager, config, magicProvider, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
+async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
     const web3Provider = new Web3Provider(magicProvider);
     const ethSigner = web3Provider.getSigner();
     const ethereumAddress = await ethSigner.getAddress();
@@ -8601,24 +8512,14 @@ async function registerZkEvmUser({ authManager, config, magicProvider, multiRoll
     catch (error) {
         throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
     }
-    let user;
-    if (config.crossSdkBridgeEnabled) {
-        const credentials = authManager.checkStoredDeviceFlowCredentials();
-        if (!credentials || !credentials.refresh_token) {
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Cross SDK bridge: Failed to refresh user details');
-        }
-        user = await authManager.refreshToken(credentials.refresh_token);
-    }
-    else {
-        user = await authManager.forceUserRefresh();
-    }
+    const user = await authManager.forceUserRefresh();
     if (!user?.zkEvm) {
         throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Failed to refresh user details');
     }
     return user;
 }
 
-const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupApiClients, jsonRpcProvider, }) => {
+const loginZkEvmUser = async ({ authManager, magicAdapter, multiRollupApiClients, jsonRpcProvider, }) => {
     let user = null;
     try {
         user = await authManager.getUser();
@@ -8628,7 +8529,7 @@ const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupAp
         console.warn('eth_requestAccounts` failed to retrieve a cached user session:', err);
     }
     if (!user) {
-        user = await authManager.getUserDeviceFlow() || await authManager.login();
+        user = await authManager.login();
     }
     if (!user.idToken) {
         throw new Error('User is missing idToken');
@@ -8638,7 +8539,6 @@ const loginZkEvmUser = async ({ authManager, config, magicAdapter, multiRollupAp
         // Generate counterfactual address and retrieve updated Auth0 user
         const userZkevm = await registerZkEvmUser({
             authManager,
-            config,
             magicProvider,
             multiRollupApiClients,
             accessToken: user.accessToken,
@@ -9062,24 +8962,12 @@ class Passport {
     async connectImx() {
         return this.passportImxProviderFactory.getProvider();
     }
-    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
-        return this.passportImxProviderFactory.getProviderWithDeviceFlow(deviceCode, interval, timeoutMs);
-    }
     getPKCEAuthorizationUrl() {
         return this.authManager.getPKCEAuthorizationUrl();
     }
     async connectImxPKCEFlow(authorizationCode, state) {
         return this.passportImxProviderFactory.getProviderWithPKCEFlow(authorizationCode, state);
     }
-    /**
-     * @returns {boolean} the stored device flow credentials if they exist
-     */
-    checkStoredDeviceFlowCredentials() {
-        return this.authManager.checkStoredDeviceFlowCredentials();
-    }
-    async connectImxWithCredentials(tokenResponse) {
-        return this.passportImxProviderFactory.getProviderWithCredentials(tokenResponse);
-    }
     connectEvm() {
         if (this.config.network === Networks.PRODUCTION) {
             throw new Error('EVM is not supported on production network');
@@ -9119,19 +9007,35 @@ class Passport {
         }
         return user ? user.profile : null;
     }
+    async loginCallback() {
+        return this.authManager.loginCallback();
+    }
     async loginWithDeviceFlow() {
         return this.authManager.loginWithDeviceFlow();
     }
-    async loginCallback() {
-        return this.authManager.loginCallback();
+    async loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs) {
+        const user = await this.authManager.loginWithDeviceFlowCallback(deviceCode, interval, timeoutMs);
+        return user.profile;
     }
     async logout() {
-        await this.authManager.logout();
         await this.confirmationScreen.logout();
+        await this.authManager.logout();
         // Code after this point is only executed if the logout mode is silent
         await this.magicAdapter.logout();
         this.passportEventEmitter.emit(PassportEvents.LOGGED_OUT);
     }
+    /**
+     * Logs the user out of Passport when using device flow authentication.
+     *
+     * @returns {Promise<string>} The device flow end session endpoint. Consumers are responsible for
+     * opening this URL in the same browser that was used to log the user in.
+     */
+    async logoutDeviceFlow() {
+        await this.authManager.removeUser();
+        await this.magicAdapter.logout();
+        this.passportEventEmitter.emit(PassportEvents.LOGGED_OUT);
+        return this.authManager.getDeviceFlowEndSessionEndpoint();
+    }
     /**
      * This method should only be called from the logout redirect uri
      * when logout mode is 'silent'.
@@ -9139,17 +9043,10 @@ class Passport {
     async logoutSilentCallback(url) {
         return this.authManager.logoutSilentCallback(url);
     }
-    async logoutDeviceFlow() {
-        return this.authManager.logoutDeviceFlow();
-    }
     async getUserInfo() {
         const user = await this.authManager.getUser();
         return user?.profile;
     }
-    async getUserInfoDeviceFlow() {
-        const user = await this.authManager.getUserDeviceFlow();
-        return user?.profile;
-    }
     async getIdToken() {
         const user = await this.authManager.getUser();
         return user?.idToken;

package/package.json

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