@imtbl/sdk 0.0.1-alpha.2 → 0.1.0-alpha

package/dist/passport.d.ts

@@ -3,6 +3,7 @@ declare enum PassportErrorType {
     INVALID_CONFIGURATION = "INVALID_CONFIGURATION",
     WALLET_CONNECTION_ERROR = "WALLET_CONNECTION_ERROR",
     NOT_LOGGED_IN_ERROR = "NOT_LOGGED_IN_ERROR",
+    SILENT_LOGIN_ERROR = "SILENT_LOGIN_ERROR",
     REFRESH_TOKEN_ERROR = "REFRESH_TOKEN_ERROR",
     USER_REGISTRATION_ERROR = "USER_REGISTRATION_ERROR",
     LOGOUT_ERROR = "LOGOUT_ERROR",
@@ -663,6 +664,23 @@ interface IMXProvider {
     completeWithdrawal(starkPublicKey: string, token: AnyToken): Promise<TransactionResponse>;
 }
 
+declare enum Environment {
+    PRODUCTION = "production",
+    SANDBOX = "sandbox"
+}
+declare class ImmutableConfiguration {
+    readonly environment: Environment;
+    readonly apiKey?: string;
+    constructor(options: {
+        environment: Environment;
+        apiKey?: string;
+    });
+}
+interface ModuleConfiguration<T> {
+    baseConfig: ImmutableConfiguration;
+    overrides?: T;
+}
+
 type UserProfile = {
     email?: string;
     nickname?: string;
@@ -672,14 +690,6 @@ declare enum Networks {
     PRODUCTION = "mainnet",
     SANDBOX = "goerli"
 }
-interface EnvironmentConfiguration {
-    network: Networks;
-    authenticationDomain: string;
-    magicPublishableApiKey: string;
-    magicProviderId: string;
-    baseIMXApiPath: string;
-    passportDomain: string;
-}
 interface OidcConfiguration {
     clientId: string;
     logoutRedirectUri: string;
@@ -687,24 +697,43 @@ interface OidcConfiguration {
     scope?: string;
     audience?: string;
 }
+interface PassportOverrides {
+    network: Networks;
+    authenticationDomain: string;
+    magicPublishableApiKey: string;
+    magicProviderId: string;
+    passportDomain: string;
+    imxApiBasePath: string;
+}
+interface PassportModuleConfiguration extends ModuleConfiguration<PassportOverrides>, OidcConfiguration {
+}
 
 declare class Passport {
     private authManager;
     private magicAdapter;
     private readonly config;
-    constructor(environmentConfiguration: EnvironmentConfiguration, oidcConfiguration: OidcConfiguration);
+    constructor(passportModuleConfiguration: PassportModuleConfiguration);
+    private getImxProvider;
+    connectImxSilent(): Promise<IMXProvider | null>;
     connectImx(): Promise<IMXProvider>;
     loginCallback(): Promise<void>;
     logout(): Promise<void>;
-    getUserInfo(): Promise<UserProfile>;
+    getUserInfo(): Promise<UserProfile | undefined>;
     getIdToken(): Promise<string | undefined>;
-    getAccessToken(): Promise<string>;
+    getAccessToken(): Promise<string | undefined>;
     private registerUser;
 }
 
-declare const Config: {
-    PRODUCTION: EnvironmentConfiguration;
-    SANDBOX: EnvironmentConfiguration;
-};
+declare class PassportConfiguration {
+    readonly network: Networks;
+    readonly authenticationDomain: string;
+    readonly passportDomain: string;
+    readonly magicPublishableApiKey: string;
+    readonly magicProviderId: string;
+    readonly imxApiBasePath: string;
+    readonly oidcConfiguration: OidcConfiguration;
+    readonly baseConfig: ImmutableConfiguration;
+    constructor({ baseConfig, overrides, ...oidcConfiguration }: PassportModuleConfiguration);
+}
 
-export { Config, Passport, PassportError };
+export { Passport, PassportConfiguration, PassportError };

package/dist/passport.js

@@ -1,8 +1,8 @@
+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 { Configuration, UsersApi, TransfersApi, OrdersApi, ExchangesApi, TradesApi, generateLegacyStarkPrivateKey, createStarkSigner } from '@imtbl/core-sdk';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
 
@@ -67,12 +67,19 @@ function convertToSignableToken(token) {
     }
 }
 
+var Environment;
+(function (Environment) {
+    Environment["PRODUCTION"] = "production";
+    Environment["SANDBOX"] = "sandbox";
+})(Environment || (Environment = {}));
+
 var PassportErrorType;
 (function (PassportErrorType) {
     PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
     PassportErrorType["INVALID_CONFIGURATION"] = "INVALID_CONFIGURATION";
     PassportErrorType["WALLET_CONNECTION_ERROR"] = "WALLET_CONNECTION_ERROR";
     PassportErrorType["NOT_LOGGED_IN_ERROR"] = "NOT_LOGGED_IN_ERROR";
+    PassportErrorType["SILENT_LOGIN_ERROR"] = "SILENT_LOGIN_ERROR";
     PassportErrorType["REFRESH_TOKEN_ERROR"] = "REFRESH_TOKEN_ERROR";
     PassportErrorType["USER_REGISTRATION_ERROR"] = "USER_REGISTRATION_ERROR";
     PassportErrorType["LOGOUT_ERROR"] = "LOGOUT_ERROR";
@@ -119,17 +126,17 @@ const retryWithDelay = async (fn, options) => {
     }
 };
 
-const getAuthConfiguration = ({ oidcConfiguration, }) => {
+const getAuthConfiguration = ({ oidcConfiguration, authenticationDomain, }) => {
     const baseConfiguration = {
-        authority: oidcConfiguration.authenticationDomain,
+        authority: authenticationDomain,
         redirect_uri: oidcConfiguration.redirectUri,
         popup_redirect_uri: oidcConfiguration.redirectUri,
         client_id: oidcConfiguration.clientId,
         metadata: {
-            authorization_endpoint: `${oidcConfiguration.authenticationDomain}/authorize`,
-            token_endpoint: `${oidcConfiguration.authenticationDomain}/oauth/token`,
-            userinfo_endpoint: `${oidcConfiguration.authenticationDomain}/userinfo`,
-            end_session_endpoint: `${oidcConfiguration.authenticationDomain}/v2/logout` +
+            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}`,
         },
@@ -154,6 +161,7 @@ class AuthManager {
     mapOidcUserToDomainModel = (oidcUser) => {
         const passport = oidcUser.profile?.passport;
         return {
+            expired: oidcUser.expired,
             idToken: oidcUser.id_token,
             accessToken: oidcUser.access_token,
             refreshToken: oidcUser.refresh_token,
@@ -167,7 +175,10 @@ class AuthManager {
     };
     async login() {
         return withPassportError(async () => {
-            const oidcUser = await this.userManager.signinPopup();
+            const popupWindowFeatures = { width: 410, height: 450 };
+            const oidcUser = await this.userManager.signinPopup({
+                popupWindowFeatures,
+            });
             return this.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.AUTHENTICATION_ERROR);
     }
@@ -177,11 +188,24 @@ class AuthManager {
     async logout() {
         return withPassportError(async () => this.userManager.signoutRedirect(), PassportErrorType.LOGOUT_ERROR);
     }
+    async loginSilent() {
+        return withPassportError(async () => {
+            const existedUser = await this.getUser();
+            if (!existedUser) {
+                return null;
+            }
+            const oidcUser = await this.userManager.signinSilent();
+            if (!oidcUser) {
+                return null;
+            }
+            return this.mapOidcUserToDomainModel(oidcUser);
+        }, PassportErrorType.SILENT_LOGIN_ERROR);
+    }
     async getUser() {
         return withPassportError(async () => {
             const oidcUser = await this.userManager.getUser();
             if (!oidcUser) {
-                throw new Error('Failed to retrieve user');
+                return null;
             }
             return this.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.NOT_LOGGED_IN_ERROR);
@@ -250,26 +274,12 @@ var TransactionTypes;
 const PassportEventType = 'imx_passport_confirmation';
 
 const openPopupCenter = ({ url, title, width, height, }) => {
-    // Fixes dual-screen position                             Most browsers      Firefox
-    const dualScreenLeft = window.screenLeft !== undefined ? window.screenLeft : window.screenX;
-    const dualScreenTop = window.screenTop !== undefined ? window.screenTop : window.screenY;
-    const windowWidth = window.innerWidth
-        ? window.innerWidth
-        : document.documentElement.clientWidth
-            ? document.documentElement.clientWidth
-            : screen.width;
-    const windowHeight = window.innerHeight
-        ? window.innerHeight
-        : document.documentElement.clientHeight
-            ? document.documentElement.clientHeight
-            : screen.height;
-    const systemZoom = windowWidth / window.screen.availWidth;
-    const left = (windowWidth - width) / 2 / systemZoom + dualScreenLeft;
-    const top = (windowHeight - height) / 2 / systemZoom + dualScreenTop;
+    const left = Math.max(0, Math.round(window.screenX + (window.outerWidth - width) / 2));
+    const top = Math.max(0, Math.round(window.screenY + (window.outerHeight - height) / 2));
     const newWindow = window.open(url, title, `
       scrollbars=yes,
-      width=${width / systemZoom}, 
-      height=${height / systemZoom}, 
+      width=${width}, 
+      height=${height}, 
       top=${top}, 
       left=${left}
      `);
@@ -281,8 +291,8 @@ const openPopupCenter = ({ url, title, width, height, }) => {
 };
 
 const ConfirmationWindowTitle = 'Confirm this transaction';
-const ConfirmationWindowHeight = 600;
-const ConfirmationWindowWidth = 600;
+const ConfirmationWindowHeight = 380;
+const ConfirmationWindowWidth = 480;
 const ConfirmationWindowClosedPollingDuration = 1000;
 class ConfirmationScreen {
     config;
@@ -296,7 +306,7 @@ class ConfirmationScreen {
             ...message,
         }, this.config.passportDomain);
     }
-    startTransaction(accessToken, transaction) {
+    startTransaction(accessToken, transaction, popupOptions) {
         return new Promise((resolve, reject) => {
             const messageHandler = ({ data, origin }) => {
                 if (origin != this.config.passportDomain ||
@@ -327,8 +337,8 @@ class ConfirmationScreen {
             const confirmationWindow = openPopupCenter({
                 url: `${this.config.passportDomain}/transaction-confirmation`,
                 title: ConfirmationWindowTitle,
-                width: ConfirmationWindowWidth,
-                height: ConfirmationWindowHeight,
+                width: popupOptions?.width || ConfirmationWindowWidth,
+                height: popupOptions?.height || ConfirmationWindowHeight,
             });
             // https://stackoverflow.com/questions/9388380/capture-the-close-event-of-popup-window-in-javascript/48240128#48240128
             const timer = setInterval(function () {
@@ -415,10 +425,11 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, pass
             getSignableTransferRequestV2,
         });
         const confirmationScreen = new ConfirmationScreen(passportConfig);
+        const popupWindowSize = { width: 480, height: 784 };
         const confirmationResult = await confirmationScreen.startTransaction(user.accessToken, {
             transactionType: TransactionTypes.CreateBatchTransfer,
             transactionData: getSignableTransferRequestV2,
-        });
+        }, popupWindowSize);
         if (!confirmationResult.confirmed) {
             throw new Error('Transaction rejected by user');
         }
@@ -627,7 +638,7 @@ async function createTrade({ request, tradesApi, user, starkSigner, passportConf
             },
         };
         const headers = { Authorization: 'Bearer ' + user.accessToken };
-        const { data: createTradeResponse } = await tradesApi.createTrade(tradeParams, {
+        const { data: createTradeResponse } = await tradesApi.createTradeV3(tradeParams, {
             headers,
         });
         return createTradeResponse;
@@ -647,7 +658,7 @@ class PassportImxProvider {
         this.starkSigner = starkSigner;
         this.passportConfig = passportConfig;
         const apiConfig = new Configuration({
-            basePath: passportConfig.imxAPIConfiguration.basePath,
+            basePath: passportConfig.imxApiBasePath,
         });
         this.transfersApi = new TransfersApi(apiConfig);
         this.ordersApi = new OrdersApi(apiConfig);
@@ -739,67 +750,75 @@ var Networks;
     Networks["SANDBOX"] = "goerli";
 })(Networks || (Networks = {}));
 
-const Config = {
-    PRODUCTION: {
-        network: Networks.PRODUCTION,
-        authenticationDomain: 'https://auth.immutable.com',
-        magicPublishableApiKey: 'pk_live_10F423798A540ED7',
-        magicProviderId: 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=',
-        baseIMXApiPath: 'https://api.x.immutable.com',
-        passportDomain: 'https://passport.immutable.com',
-    },
-    SANDBOX: {
-        network: Networks.SANDBOX,
-        authenticationDomain: 'https://auth.immutable.com',
-        magicPublishableApiKey: 'pk_live_10F423798A540ED7',
-        magicProviderId: 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=',
-        baseIMXApiPath: 'https://api.sandbox.x.immutable.com',
-        passportDomain: 'https://passport.sandbox.immutable.com',
-    },
-};
-const validateConfiguration = (configurationName, configuration, requiredKeys) => {
-    if (!configuration) {
-        throw new PassportError(`${configurationName} cannot be null`, PassportErrorType.INVALID_CONFIGURATION);
-    }
+const validateConfiguration = (configuration, requiredKeys, prefix) => {
     const missingKeys = requiredKeys
         .map((key) => !configuration[key] && key)
         .filter((n) => n)
         .join(', ');
     if (missingKeys !== '') {
-        throw new PassportError(`${configurationName} - ${missingKeys} cannot be null`, PassportErrorType.INVALID_CONFIGURATION);
+        const errorMessage = prefix
+            ? `${prefix} - ${missingKeys} cannot be null`
+            : `${missingKeys} cannot be null`;
+        throw new PassportError(errorMessage, PassportErrorType.INVALID_CONFIGURATION);
     }
 };
-const getPassportConfiguration = (environmentConfiguration, oidcConfiguration) => {
-    validateConfiguration('EnvironmentConfiguration', environmentConfiguration, [
-        'network',
-        'authenticationDomain',
-        'magicPublishableApiKey',
-        'magicProviderId',
-        'passportDomain',
-    ]);
-    validateConfiguration('OidcConfiguration', oidcConfiguration, [
-        'clientId',
-        'logoutRedirectUri',
-        'redirectUri',
-    ]);
-    return {
-        network: environmentConfiguration.network,
-        oidcConfiguration: {
-            authenticationDomain: environmentConfiguration.authenticationDomain,
-            clientId: oidcConfiguration.clientId,
-            logoutRedirectUri: oidcConfiguration.logoutRedirectUri,
-            redirectUri: oidcConfiguration.redirectUri,
-            scope: oidcConfiguration.scope,
-            audience: oidcConfiguration.audience,
-        },
-        imxAPIConfiguration: {
-            basePath: environmentConfiguration.baseIMXApiPath,
-        },
-        passportDomain: environmentConfiguration.passportDomain,
-        magicPublishableApiKey: environmentConfiguration.magicPublishableApiKey,
-        magicProviderId: environmentConfiguration.magicProviderId,
-    };
-};
+class PassportConfiguration {
+    network;
+    authenticationDomain;
+    passportDomain;
+    magicPublishableApiKey;
+    magicProviderId;
+    imxApiBasePath;
+    oidcConfiguration;
+    baseConfig;
+    constructor({ baseConfig, overrides, ...oidcConfiguration }) {
+        validateConfiguration(oidcConfiguration, [
+            'clientId',
+            'logoutRedirectUri',
+            'redirectUri',
+        ]);
+        this.oidcConfiguration = oidcConfiguration;
+        this.baseConfig = baseConfig;
+        if (overrides) {
+            validateConfiguration(overrides, [
+                'network',
+                'authenticationDomain',
+                '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) {
+                case Environment.SANDBOX: {
+                    this.network = Networks.SANDBOX;
+                    this.authenticationDomain = 'https://auth.immutable.com';
+                    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: {
+                    this.network = Networks.PRODUCTION;
+                    this.authenticationDomain = 'https://auth.immutable.com';
+                    this.magicPublishableApiKey = 'pk_live_10F423798A540ED7';
+                    this.magicProviderId = 'fSMzaRQ4O7p4fttl7pCyGVtJS_G70P8SNsLXtPPGHo0=';
+                    this.passportDomain = 'https://passport.immutable.com';
+                    this.imxApiBasePath = 'https://api.x.immutable.com';
+                    break;
+                }
+            }
+        }
+    }
+}
 
 const getStarkSigner = async (signer) => {
     return withPassportError(async () => {
@@ -838,15 +857,14 @@ class Passport {
     authManager;
     magicAdapter;
     config;
-    constructor(environmentConfiguration, oidcConfiguration) {
-        const passportConfiguration = getPassportConfiguration(environmentConfiguration, oidcConfiguration);
+    constructor(passportModuleConfiguration) {
+        const passportConfiguration = new PassportConfiguration(passportModuleConfiguration);
         this.config = passportConfiguration;
         this.authManager = new AuthManager(this.config);
         this.magicAdapter = new MagicAdapter(this.config);
     }
-    async connectImx() {
-        const user = await this.authManager.login();
-        if (!user.idToken) {
+    async getImxProvider(user) {
+        if (!user || !user.idToken) {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
         }
         const provider = await this.magicAdapter.login(user.idToken);
@@ -867,6 +885,17 @@ class Passport {
             passportConfig: this.config,
         });
     }
+    async connectImxSilent() {
+        const user = await this.authManager.loginSilent();
+        if (!user) {
+            return null;
+        }
+        return this.getImxProvider(user);
+    }
+    async connectImx() {
+        const user = await this.authManager.login();
+        return this.getImxProvider(user);
+    }
     async loginCallback() {
         return this.authManager.loginCallback();
     }
@@ -875,19 +904,19 @@ class Passport {
     }
     async getUserInfo() {
         const user = await this.authManager.getUser();
-        return user.profile;
+        return user?.profile;
     }
     async getIdToken() {
         const user = await this.authManager.getUser();
-        return user.idToken;
+        return user?.idToken;
     }
     async getAccessToken() {
         const user = await this.authManager.getUser();
-        return user.accessToken;
+        return user?.accessToken;
     }
     async registerUser(userAdminKeySigner, starkSigner, jwt) {
         const configuration = new Configuration({
-            basePath: this.config.imxAPIConfiguration.basePath,
+            basePath: this.config.imxApiBasePath,
         });
         const usersApi = new UsersApi(configuration);
         await registerPassport({
@@ -903,4 +932,4 @@ class Passport {
     }
 }
 
-export { Config, Passport, PassportError };
+export { Passport, PassportConfiguration, PassportError };

package/dist/provider.d.ts

@@ -1,3 +1,5 @@
+import { ProviderConfiguration as ProviderConfiguration$1 } from 'config';
+
 declare type Bytes = ArrayLike<number>;
 declare type BytesLike = Bytes | string;
 interface Hexable {
@@ -329,7 +331,7 @@ interface ConfigurationParameters {
     baseOptions?: any;
     formDataCtor?: new () => any;
 }
-declare class Configuration$1 {
+declare class Configuration {
     /**
      * parameter for apiKey security
      * @param name security name
@@ -811,7 +813,7 @@ interface ImmutableXConfiguration {
     /**
      * The configuration for the API client
      */
-    apiConfiguration: Configuration$1;
+    apiConfiguration: Configuration;
     /**
      * The configuration for the Ethereum network
      */
@@ -903,24 +905,10 @@ interface IMXProvider {
     completeWithdrawal(starkPublicKey: string, token: AnyToken): Promise<TransactionResponse>;
 }
 
-declare enum Environment {
-    DEVELOPMENT = "development",
-    SANDBOX = "sandbox",
-    PRODUCTION = "production"
-}
-type StarkExConfig = ImmutableXConfiguration & {
-    env: Environment;
-};
-declare class Configuration {
-    private readonly starkExConfig;
-    constructor(config: StarkExConfig);
-    getStarkExConfig(): StarkExConfig;
-}
-
 declare class GenericIMXProvider implements IMXProvider {
     private readonly config;
     private readonly signers;
-    constructor(config: Configuration, ethSigner: Signer, starkExSigner: StarkSigner);
+    constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkSigner: StarkSigner);
     getAddress(): Promise<string>;
     registerOffchain(): Promise<RegisterUserResponse>;
     batchNftTransfer(request: Array<NftTransferDetails>): Promise<CreateTransferResponse>;
@@ -937,10 +925,38 @@ declare class GenericIMXProvider implements IMXProvider {
 
 declare class MetaMaskIMXProvider extends GenericIMXProvider {
     private static imxSigner;
-    constructor(config: Configuration, ethSigner: Signer, starkExSigner: StarkSigner);
-    static connect(config: Configuration): Promise<MetaMaskIMXProvider>;
+    constructor(config: ProviderConfiguration$1, ethSigner: Signer, starkSigner: StarkSigner);
+    static connect(config: ProviderConfiguration$1): Promise<MetaMaskIMXProvider>;
     static disconnect(): Promise<void>;
     static signMessage(message: string): Promise<string>;
 }
 
-export { GenericIMXProvider, IMXProvider, MetaMaskIMXProvider };
+declare enum Environment {
+    PRODUCTION = "production",
+    SANDBOX = "sandbox"
+}
+declare class ImmutableConfiguration {
+    readonly environment: Environment;
+    readonly apiKey?: string;
+    constructor(options: {
+        environment: Environment;
+        apiKey?: string;
+    });
+}
+interface ModuleConfiguration<T> {
+    baseConfig: ImmutableConfiguration;
+    overrides?: T;
+}
+
+interface ProviderOverrides {
+    immutableXConfig: ImmutableXConfiguration;
+}
+interface ProviderModuleConfiguration extends ModuleConfiguration<ProviderOverrides> {
+}
+declare class ProviderConfiguration {
+    readonly immutableXConfig: ImmutableXConfiguration;
+    readonly baseConfig: ImmutableConfiguration;
+    constructor({ baseConfig, overrides }: ProviderModuleConfiguration);
+}
+
+export { GenericIMXProvider, IMXProvider, MetaMaskIMXProvider, ProviderConfiguration };