@imtbl/sdk 0.2.0-alpha → 0.2.1-alpha

package/dist/passport.js

@@ -1,5 +1,7 @@
 import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 import { UserManager } from 'oidc-client-ts';
+import axios$1 from 'axios';
+import jwt_decode from 'jwt-decode';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
 import BN from 'bn.js';
@@ -21,7 +23,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.2.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.2.1-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -4289,6 +4291,43 @@ const withPassportError = async (fn, customErrorType) => {
     }
 };
 
+const keyCrendentials = 'passport_credentials';
+const validCredentialsMinTtlSec = 3600; // 1 hour
+class DeviceCredentialsManager {
+    saveCredentials(tokenResponse) {
+        localStorage.setItem(keyCrendentials, JSON.stringify(tokenResponse));
+    }
+    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);
+            const idTokenValid = this.isTokenValid(tokenResponse.id_token);
+            return accessTokenValid && idTokenValid;
+        }
+        return false;
+    }
+    isTokenValid(jwt) {
+        const tokenPayload = jwt_decode(jwt);
+        const expiresAt = tokenPayload.exp ?? 0;
+        const now = (Date.now() / 1000) + validCredentialsMinTtlSec;
+        return expiresAt > now;
+    }
+    clearCredentials() {
+        localStorage.removeItem(keyCrendentials);
+    }
+}
+
+const formUrlEncodedHeader = {
+    headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+    },
+};
 const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
     const baseConfiguration = {
         authority: authenticationDomain,
@@ -4314,12 +4353,19 @@ const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
     }
     return baseConfiguration;
 };
+function wait$1(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 class AuthManager {
     userManager;
     config;
+    deviceCredentialsManager;
     constructor(config) {
         this.config = config;
         this.userManager = new UserManager(getAuthConfiguration(config));
+        this.deviceCredentialsManager = new DeviceCredentialsManager();
     }
     static mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
@@ -4349,6 +4395,27 @@ class AuthManager {
         }
         return user;
     };
+    static mapDeviceTokenResponseToDomainUserModel = (tokenResponse) => {
+        const idTokenPayload = jwt_decode(tokenResponse.id_token);
+        const user = {
+            idToken: tokenResponse.id_token,
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token,
+            profile: {
+                sub: idTokenPayload.sub,
+                email: idTokenPayload.email,
+                nickname: idTokenPayload.nickname,
+            },
+        };
+        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,
+            };
+        }
+        return user;
+    };
     async login() {
         return withPassportError(async () => {
             const popupWindowFeatures = { width: 410, height: 450 };
@@ -4361,9 +4428,104 @@ class AuthManager {
     async loginCallback() {
         return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
     }
+    async loginWithDeviceFlow() {
+        return withPassportError(async () => {
+            const response = await axios$1.post(`${this.config.authenticationDomain}/oauth/device/code`, {
+                client_id: this.config.oidcConfiguration.clientId,
+                scope: this.config.oidcConfiguration.scope,
+                audience: this.config.oidcConfiguration.audience,
+            }, formUrlEncodedHeader);
+            return {
+                code: response.data.user_code,
+                deviceCode: response.data.device_code,
+                url: response.data.verification_uri_complete,
+                interval: response.data.interval,
+            };
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    /* eslint-disable no-await-in-loop */
+    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
+        return withPassportError(async () => {
+            const startTime = Date.now();
+            const loopCondition = true;
+            while (loopCondition) {
+                if (timeoutMs != null && Date.now() - startTime > timeoutMs) {
+                    throw new Error('Timed out');
+                }
+                await wait$1(interval * 1000);
+                try {
+                    const tokenResponse = await this.getDeviceFlowToken(deviceCode);
+                    const user = AuthManager.mapDeviceTokenResponseToDomainUserModel(tokenResponse);
+                    // Only persist credentials that contain the necessary data
+                    if (user.imx?.ethAddress && user.imx?.starkAddress && user.imx?.userAdminAddress) {
+                        this.deviceCredentialsManager.saveCredentials(tokenResponse);
+                    }
+                    return user;
+                }
+                catch (error) {
+                    if (axios$1.isAxiosError(error)) {
+                        const responseError = error.response?.data;
+                        switch (responseError.error) {
+                            case 'authorization_pending':
+                                break;
+                            case 'slow_down':
+                                break;
+                            case 'expired_token':
+                                throw new Error('Token expired, please log in again');
+                            case 'access_denied':
+                                throw new Error('User denied access');
+                            default:
+                                throw new Error('Error getting token');
+                        }
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            throw new Error('Failed to get credentials');
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    /* eslint-enable no-await-in-loop */
+    async getDeviceFlowToken(deviceCode) {
+        const response = await axios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
+            client_id: this.config.oidcConfiguration.clientId,
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code: deviceCode,
+        }, 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 newTokenResponse = await this.refreshToken(refreshToken);
+                return AuthManager.mapDeviceTokenResponseToDomainUserModel(newTokenResponse);
+            }
+            return null;
+        }, PassportErrorType.AUTHENTICATION_ERROR);
+    }
+    async refreshToken(refreshToken) {
+        const response = await axios$1.post(`${this.config.authenticationDomain}/oauth/token`, {
+            client_id: this.config.oidcConfiguration.clientId,
+            grant_type: 'refresh_token',
+            refresh_token: refreshToken,
+        }, formUrlEncodedHeader);
+        return response.data;
+    }
     async logout() {
         return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
     }
+    async logoutDeviceFlow() {
+        return withPassportError(async () => {
+            this.deviceCredentialsManager.clearCredentials();
+        }, PassportErrorType.LOGOUT_ERROR);
+    }
     async loginSilent() {
         return withPassportError(async () => {
             const existedUser = await this.getUser();
@@ -4380,12 +4542,28 @@ class AuthManager {
     async getUser() {
         return withPassportError(async () => {
             const oidcUser = await this.userManager.getUser();
-            if (!oidcUser) {
-                return null;
+            if (oidcUser) {
+                return AuthManager.mapOidcUserToDomainModel(oidcUser);
             }
-            return AuthManager.mapOidcUserToDomainModel(oidcUser);
+            const deviceToken = this.deviceCredentialsManager.getCredentials();
+            if (deviceToken) {
+                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            }
+            return null;
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
     }
+    async getUserDeviceFlow() {
+        return withPassportError(async () => {
+            const deviceToken = this.deviceCredentialsManager.getCredentials();
+            if (deviceToken) {
+                return AuthManager.mapDeviceTokenResponseToDomainUserModel(deviceToken);
+            }
+            return null;
+        }, PassportErrorType.NOT_LOGGED_IN_ERROR);
+    }
+    checkStoredDeviceFlowCredentials() {
+        return this.deviceCredentialsManager.getCredentials();
+    }
 }
 
 class MagicAdapter {
@@ -4913,6 +5091,17 @@ 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 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);
@@ -5220,16 +5409,38 @@ class Passport {
     async connectImx() {
         return this.passportImxProviderFactory.getProvider();
     }
+    async loginWithDeviceFlow() {
+        return this.authManager.loginWithDeviceFlow();
+    }
+    async connectImxDeviceFlow(deviceCode, interval, timeoutMs) {
+        return this.passportImxProviderFactory.getProviderWithDeviceFlow(deviceCode, interval, timeoutMs);
+    }
+    /**
+     * @returns {boolean} the stored device flow credentials if they exist
+     */
+    checkStoredDeviceFlowCredentials() {
+        return this.authManager.checkStoredDeviceFlowCredentials();
+    }
+    async connectImxWithCredentials(tokenResponse) {
+        return this.passportImxProviderFactory.getProviderWithCredentials(tokenResponse);
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
     async logout() {
         return this.authManager.logout();
     }
+    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.2.0-alpha",
+  "version": "0.2.1-alpha",
   "author": "Immutable",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
   "dependencies": {
@@ -110,6 +110,7 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "peerDependencies": {
+    "ethers": "^5.7.2",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },