@imtbl/sdk 0.2.0-alpha → 0.2.2-alpha

package/dist/index.js

@@ -2,6 +2,7 @@ import axios$2 from 'axios';
 import { ImmutableX, Config, generateLegacyStarkPrivateKey, createStarkSigner, TransfersApi, OrdersApi as OrdersApi$1, UsersApi, Contracts, TradesApi, ExchangesApi, WithdrawalsApi, MintsApi, DepositsApi, EncodingApi, TokensApi as TokensApi$1 } from '@imtbl/core-sdk';
 export { createStarkSigner as imxClientCreateStarkSigner, generateLegacyStarkPrivateKey as imxClientGenerateLegacyStarkPrivateKey } from '@imtbl/core-sdk';
 import { UserManager } from 'oidc-client-ts';
+import jwt_decode from 'jwt-decode';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
 import BN$2 from 'bn.js';
@@ -5436,7 +5437,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.2.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.2.2-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -5702,7 +5703,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.2.0-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.2.2-alpha',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -9979,6 +9980,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,
@@ -10004,12 +10042,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;
@@ -10039,6 +10084,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 };
@@ -10051,9 +10117,104 @@ class AuthManager {
     async loginCallback() {
         return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
     }
+    async loginWithDeviceFlow() {
+        return withPassportError(async () => {
+            const response = await axios$2.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$2.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$2.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$2.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();
@@ -10070,12 +10231,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 {
@@ -10603,6 +10780,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);
@@ -10910,16 +11098,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;
@@ -12814,16 +13024,14 @@ class Orderbook {
         if (!maybeConfig) {
             throw new Error('Orderbook configuration not passed, either select one of the preseet chainNames or pass in localConfig');
         }
+        const { chainName, provider } = config.overrides;
+        maybeConfig.provider = provider
+            || maybeConfig.provider;
         this.orderbookConfig = maybeConfig;
         const { apiEndpoint } = this.orderbookConfig;
         if (!apiEndpoint) {
             throw new Error('API endpoint must be provided as an override');
         }
-        // TODO: Move chainId lookup to a map based on env. Just using override to get dev started
-        const chainName = config.overrides?.chainName;
-        if (!chainName) {
-            throw new Error('chainName must be provided as an override');
-        }
         this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainName, this.orderbookConfig.seaportContractAddress).create();
         const seaportLibFactory = new SeaportLibFactory(this.orderbookConfig.seaportContractAddress, this.orderbookConfig.provider);
         this.seaport = new Seaport(seaportLibFactory, this.orderbookConfig.provider, this.orderbookConfig.seaportContractAddress, this.orderbookConfig.zoneContractAddress);
@@ -27709,7 +27917,7 @@ class $a8cb37a3fc8eb863$export$1f60ba4ec72508a0 {
 function $parcel$export(e, n, v, s) {
   Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
 }
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.0-alpha";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.2.2-alpha";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/orderbook.js

@@ -1887,16 +1887,14 @@ class Orderbook {
         if (!maybeConfig) {
             throw new Error('Orderbook configuration not passed, either select one of the preseet chainNames or pass in localConfig');
         }
+        const { chainName, provider } = config.overrides;
+        maybeConfig.provider = provider
+            || maybeConfig.provider;
         this.orderbookConfig = maybeConfig;
         const { apiEndpoint } = this.orderbookConfig;
         if (!apiEndpoint) {
             throw new Error('API endpoint must be provided as an override');
         }
-        // TODO: Move chainId lookup to a map based on env. Just using override to get dev started
-        const chainName = config.overrides?.chainName;
-        if (!chainName) {
-            throw new Error('chainName must be provided as an override');
-        }
         this.apiClient = new ImmutableApiClientFactory(apiEndpoint, chainName, this.orderbookConfig.seaportContractAddress).create();
         const seaportLibFactory = new SeaportLibFactory(this.orderbookConfig.seaportContractAddress, this.orderbookConfig.provider);
         this.seaport = new Seaport(seaportLibFactory, this.orderbookConfig.provider, this.orderbookConfig.seaportContractAddress, this.orderbookConfig.zoneContractAddress);

package/dist/passport.d.ts

@@ -10488,6 +10488,19 @@ interface PassportOverrides {
 }
 interface PassportModuleConfiguration extends ModuleConfiguration<PassportOverrides>, OidcConfiguration {
 }
+type DeviceConnectResponse = {
+    code: string;
+    deviceCode: string;
+    url: string;
+    interval: number;
+};
+type DeviceTokenResponse = {
+    access_token: string;
+    refresh_token?: string;
+    id_token: string;
+    token_type: string;
+    expires_in: number;
+};
 
 declare class Passport {
     private readonly authManager;
@@ -10499,11 +10512,20 @@ declare class Passport {
     constructor(passportModuleConfiguration: PassportModuleConfiguration);
     connectImxSilent(): Promise<IMXProvider | null>;
     connectImx(): Promise<IMXProvider>;
+    loginWithDeviceFlow(): Promise<DeviceConnectResponse>;
+    connectImxDeviceFlow(deviceCode: string, interval: number, timeoutMs?: number): Promise<IMXProvider | null>;
+    /**
+     * @returns {boolean} the stored device flow credentials if they exist
+     */
+    checkStoredDeviceFlowCredentials(): DeviceTokenResponse | null;
+    connectImxWithCredentials(tokenResponse: DeviceTokenResponse): Promise<IMXProvider | null>;
     loginCallback(): Promise<void>;
     logout(): Promise<void>;
+    logoutDeviceFlow(): Promise<void>;
     getUserInfo(): Promise<UserProfile | undefined>;
+    getUserInfoDeviceFlow(): Promise<UserProfile | undefined>;
     getIdToken(): Promise<string | undefined>;
     getAccessToken(): Promise<string | undefined>;
 }
 
-export { Networks, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, UserProfile };
+export { DeviceConnectResponse, DeviceTokenResponse, Networks, Passport, PassportError, PassportModuleConfiguration, PassportOverrides, UserProfile };