@imtbl/sdk 0.28.10 → 0.29.0

package/dist/index.cjs

@@ -7,10 +7,10 @@ var jwt_decode = require('jwt-decode');
 var crypto = require('crypto');
 var magicSdk = require('magic-sdk');
 var oidc = require('@magic-ext/oidc');
+var providers = require('@ethersproject/providers');
 var ethers = require('ethers');
 var BN$2 = require('bn.js');
 var encUtils = require('enc-utils');
-var providers = require('@ethersproject/providers');
 var events = require('events');
 var abi = require('@0xsequence/abi');
 var config$1 = require('@0xsequence/config');
@@ -57,34 +57,38 @@ class ImmutableConfiguration {
     environment;
     rateLimitingKey;
     apiKey;
-    clientAppId;
+    publishableKey;
     constructor(options) {
         this.environment = options.environment;
-        if (options.rateLimitingKey) {
-            this.rateLimitingKey = options.rateLimitingKey;
-            globalAxios$1.defaults.headers.common['x-api-key'] = this.rateLimitingKey;
-        }
-        if (options.apiKey) {
-            if (!options.apiKey.startsWith('sk_imapik-')) {
-                throw new Error('Invalid API key');
-            }
-            this.apiKey = options.apiKey;
-            globalAxios$1.defaults.headers.common['x-immutable-api-key'] = this.apiKey;
-        }
-        if (options.clientAppId) {
-            if (!options.clientAppId.startsWith('cai_imapik-')) {
-                throw new Error('Invalid Client App Id');
-            }
-            this.clientAppId = options.clientAppId;
-            globalAxios$1.defaults.headers.common['x-immutable-client-app-id'] = this.clientAppId;
-        }
     }
 }
+const API_KEY_PREFIX = 'sk_imapik-';
+const PUBLISHABLE_KEY_PREFIX = 'pk_imapik-';
+const PUBLISHABLE_KEY_LENGTH = 30;
+const addApiKeyToAxiosHeader = (apiKey) => {
+    if (!apiKey.startsWith(API_KEY_PREFIX)) {
+        throw new Error('Invalid API key. Create your api key in Immutable developer hub. https://hub.immutable.com');
+    }
+    globalAxios$1.defaults.headers.common['x-immutable-api-key'] = apiKey;
+};
+const addPublishableKeyToAxiosHeader = (publishableKey) => {
+    if (!publishableKey.startsWith(PUBLISHABLE_KEY_PREFIX) || publishableKey.length !== PUBLISHABLE_KEY_LENGTH) {
+        throw new Error('Invalid Publishable key. Create your Publishable key in Immutable developer hub.'
+            + ' https://hub.immutable.com');
+    }
+    globalAxios$1.defaults.headers.common['x-immutable-publishable-key'] = publishableKey;
+};
+const addRateLimitingKeyToAxiosHeader = (rateLimitingKey) => {
+    globalAxios$1.defaults.headers.common['x-api-key'] = rateLimitingKey;
+};
 
 var config = /*#__PURE__*/Object.freeze({
     __proto__: null,
     get Environment () { return Environment$1; },
-    ImmutableConfiguration: ImmutableConfiguration
+    ImmutableConfiguration: ImmutableConfiguration,
+    addApiKeyToAxiosHeader: addApiKeyToAxiosHeader,
+    addPublishableKeyToAxiosHeader: addPublishableKeyToAxiosHeader,
+    addRateLimitingKeyToAxiosHeader: addRateLimitingKeyToAxiosHeader
 });
 
 /* tslint:disable */
@@ -3651,7 +3655,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.28.10' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-0.29.0' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -3711,7 +3715,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.10',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.29.0',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -4122,7 +4126,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.28.10',
+    sdkVersion: 'ts-immutable-sdk-0.29.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -8777,9 +8781,9 @@ class AuthManager {
         };
         if (passport?.imx_eth_address) {
             user.imx = {
-                ethAddress: passport?.imx_eth_address,
-                starkAddress: passport?.imx_stark_address,
-                userAdminAddress: passport?.imx_user_admin_address,
+                ethAddress: passport.imx_eth_address,
+                starkAddress: passport.imx_stark_address,
+                userAdminAddress: passport.imx_user_admin_address,
             };
         }
         if (passport?.zkevm_eth_address) {
@@ -8802,11 +8806,11 @@ class AuthManager {
                 nickname: idTokenPayload.nickname,
             },
         };
-        if (idTokenPayload?.passport?.imx_eth_address) {
+        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,
+                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) {
@@ -9067,7 +9071,7 @@ class AuthManager {
     }
 }
 
-const lazyLoad = (promiseToAwait, initialiseFunction) => (promiseToAwait().then(initialiseFunction));
+const lazyLoad = (promiseToAwait, initialiseFunction) => promiseToAwait().then(initialiseFunction);
 const lazyDocumentReady = (initialiseFunction) => {
     const documentReadyPromise = () => new Promise((resolve) => {
         if (window.document.readyState === 'complete') {
@@ -9481,33 +9485,31 @@ async function cancelOrder$1({ user, starkSigner, request, ordersApi, guardianCl
 }
 
 async function registerPassport({ ethSigner, starkSigner, usersApi }, authorization) {
-    return withPassportError(async () => {
-        const [userAddress, starkPublicKey] = await Promise.all([
-            ethSigner.getAddress(),
-            starkSigner.getAddress(),
-        ]);
-        const signableResult = await usersApi.getSignableRegistrationOffchain({
-            getSignableRegistrationRequest: {
-                ether_key: userAddress,
-                stark_key: starkPublicKey,
-            },
-        });
-        const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
-        const [ethSignature, starkSignature] = await Promise.all([
-            signRaw(signableMessage, ethSigner),
-            starkSigner.signMessage(payloadHash),
-        ]);
-        const response = await usersApi.registerPassportUser({
-            authorization: `Bearer ${authorization}`,
-            registerPassportUserRequest: {
-                eth_signature: ethSignature,
-                ether_key: userAddress,
-                stark_signature: starkSignature,
-                stark_key: starkPublicKey,
-            },
-        });
-        return response.statusText;
-    }, PassportErrorType.USER_REGISTRATION_ERROR);
+    const [userAddress, starkPublicKey] = await Promise.all([
+        ethSigner.getAddress(),
+        starkSigner.getAddress(),
+    ]);
+    const signableResult = await usersApi.getSignableRegistrationOffchain({
+        getSignableRegistrationRequest: {
+            ether_key: userAddress,
+            stark_key: starkPublicKey,
+        },
+    });
+    const { signable_message: signableMessage, payload_hash: payloadHash } = signableResult.data;
+    const [ethSignature, starkSignature] = await Promise.all([
+        signRaw(signableMessage, ethSigner),
+        starkSigner.signMessage(payloadHash),
+    ]);
+    const response = await usersApi.registerPassportUser({
+        authorization: `Bearer ${authorization}`,
+        registerPassportUserRequest: {
+            eth_signature: ethSignature,
+            ether_key: userAddress,
+            stark_signature: starkSignature,
+            stark_key: starkPublicKey,
+        },
+    });
+    return response.data;
 }
 
 async function createTrade$1({ request, tradesApi, user, starkSigner, guardianClient, }) {
@@ -9653,37 +9655,123 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
     }), PassportErrorType.TRANSFER_ERROR);
 }
 
+async function forceUserRefresh(authManager) {
+    // User metadata is updated asynchronously. Poll userinfo endpoint until it is updated.
+    await retryWithDelay(async () => {
+        const user = await authManager.loginSilent({ forceRefresh: true }); // force refresh to get updated user info
+        if (user?.imx)
+            return user;
+        return Promise.reject(new Error('user wallet addresses not exist'));
+    });
+}
+async function registerOffchain$1(userAdminKeySigner, starkSigner, unregisteredUser, authManager, usersApi) {
+    return withPassportError(async () => {
+        try {
+            const response = await registerPassport({
+                ethSigner: userAdminKeySigner,
+                starkSigner,
+                usersApi,
+            }, unregisteredUser.accessToken);
+            await forceUserRefresh(authManager);
+            return response;
+        }
+        catch (err) {
+            if (globalAxios$1.isAxiosError(err) && err.status === 409) {
+                // The user already registered, but the user token is not updated yet.
+                await forceUserRefresh(authManager);
+                return { tx_hash: '' };
+            }
+            throw err;
+        }
+    }, PassportErrorType.USER_REGISTRATION_ERROR);
+}
+
 class PassportImxProvider {
     authManager;
-    starkSigner;
     immutableXClient;
     guardianClient;
-    constructor({ authManager, starkSigner, immutableXClient, confirmationScreen, config, passportEventEmitter, }) {
+    magicAdapter;
+    /**
+     * This property is set during initialisation and stores the signers in a promise.
+     * This property is not meant to be accessed directly, but through the
+     * `getAuthenticatedUserAndSigners` method.
+     * @see getAuthenticatedUserAndSigners
+     */
+    signers;
+    signerInitialisationError;
+    constructor({ authManager, immutableXClient, confirmationScreen, config, passportEventEmitter, magicAdapter, }) {
         this.authManager = authManager;
-        this.starkSigner = starkSigner;
         this.immutableXClient = immutableXClient;
         this.guardianClient = new GuardianClient({
             confirmationScreen,
             config,
         });
+        this.magicAdapter = magicAdapter;
+        this.initialiseSigners();
         passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
     }
     handleLogout = () => {
-        this.starkSigner = undefined;
+        this.signers = undefined;
     };
-    async getAuthenticatedUserSigner() {
+    /**
+     * This method is called by the constructor and asynchronously initialises the signers.
+     * The signers are stored in a promise so that they can be retrieved by the provider
+     * when needed.
+     *
+     * If an error is thrown during initialisation, it is stored in the `signerInitialisationError`,
+     * so that it doesn't result in an unhandled promise rejection.
+     *
+     * This error is thrown when the signers are requested through:
+     * @see getAuthenticatedUserAndSigners
+     *
+     */
+    async initialiseSigners() {
+        const generateSigners = async () => {
+            const user = await this.authManager.getUser();
+            // The user will be present because the factory validates it
+            const magicRpcProvider = await this.magicAdapter.login(user.idToken);
+            const web3Provider = new providers.Web3Provider(magicRpcProvider);
+            const ethSigner = web3Provider.getSigner();
+            const starkSigner = await getStarkSigner(ethSigner);
+            return { ethSigner, starkSigner };
+        };
+        // eslint-disable-next-line no-async-promise-executor
+        this.signers = new Promise(async (resolve) => {
+            try {
+                resolve(await generateSigners());
+            }
+            catch (err) {
+                // Capture and store the initialization error
+                this.signerInitialisationError = err;
+                resolve(undefined);
+            }
+        });
+    }
+    async getAuthenticatedUserAndSigners() {
         const user = await this.authManager.getUser();
-        if (!user || this.starkSigner === undefined) {
+        if (!user || !this.signers) {
             throw new PassportError('User has been logged out', PassportErrorType.NOT_LOGGED_IN_ERROR);
         }
+        const signers = await this.signers;
+        // Throw the stored error if the signers failed to initialise
+        if (typeof signers === 'undefined') {
+            if (typeof this.signerInitialisationError !== 'undefined') {
+                throw this.signerInitialisationError;
+            }
+            throw new Error('Signers failed to initialise');
+        }
+        return { user, ...signers };
+    }
+    async getRegisteredImxUserAndSigners() {
+        const { user, starkSigner, ethSigner } = await this.getAuthenticatedUserAndSigners();
         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 };
+        return { user, starkSigner, ethSigner };
     }
     async transfer(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return transfer$1({
             request,
             user,
@@ -9692,23 +9780,21 @@ class PassportImxProvider {
             guardianClient: this.guardianClient,
         });
     }
-    // TODO: Remove once implemented
-    // eslint-disable-next-line class-methods-use-this
-    registerOffchain() {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    async registerOffchain() {
+        const { user, ethSigner, starkSigner } = await this.getAuthenticatedUserAndSigners();
+        return await registerOffchain$1(ethSigner, starkSigner, user, this.authManager, this.immutableXClient.usersApi);
     }
-    // TODO: Remove once implemented
-    // eslint-disable-next-line class-methods-use-this
-    isRegisteredOffchain() {
-        throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
+    async isRegisteredOffchain() {
+        const { user } = await this.getAuthenticatedUserAndSigners();
+        return !!user.imx;
     }
     // TODO: Remove once implemented
-    // eslint-disable-next-line class-methods-use-this
+    // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
     isRegisteredOnchain() {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     async createOrder(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return createOrder$1({
             request,
             user,
@@ -9718,7 +9804,7 @@ class PassportImxProvider {
         });
     }
     async cancelOrder(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return cancelOrder$1({
             request,
             user,
@@ -9728,7 +9814,7 @@ class PassportImxProvider {
         });
     }
     async createTrade(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return createTrade$1({
             request,
             user,
@@ -9738,7 +9824,7 @@ class PassportImxProvider {
         });
     }
     async batchNftTransfer(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return batchNftTransfer({
             request,
             user,
@@ -9748,7 +9834,7 @@ class PassportImxProvider {
         });
     }
     async exchangeTransfer(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return exchangeTransfer$1({
             request,
             user,
@@ -9776,7 +9862,7 @@ class PassportImxProvider {
         throw new PassportError('Operation not supported', PassportErrorType.OPERATION_NOT_SUPPORTED_ERROR);
     }
     async getAddress() {
-        const { user } = await this.getAuthenticatedUserSigner();
+        const { user } = await this.getRegisteredImxUserAndSigners();
         return Promise.resolve(user.imx.ethAddress);
     }
 }
@@ -9836,49 +9922,15 @@ class PassportImxProviderFactory {
         if (!user.idToken) {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
         }
-        const magicRpcProvider = await this.magicAdapter.login(user.idToken);
-        const web3Provider = new providers.Web3Provider(magicRpcProvider);
-        const ethSigner = web3Provider.getSigner();
-        const starkSigner = await getStarkSigner(ethSigner);
-        if (!user.imx?.ethAddress) {
-            await this.registerStarkEx(ethSigner, starkSigner, user.accessToken);
-            return new PassportImxProvider({
-                authManager: this.authManager,
-                starkSigner,
-                immutableXClient: this.immutableXClient,
-                confirmationScreen: this.confirmationScreen,
-                config: this.config,
-                passportEventEmitter: this.passportEventEmitter,
-            });
-        }
         return new PassportImxProvider({
+            config: this.config,
             authManager: this.authManager,
-            starkSigner,
             immutableXClient: this.immutableXClient,
             confirmationScreen: this.confirmationScreen,
-            config: this.config,
             passportEventEmitter: this.passportEventEmitter,
+            magicAdapter: this.magicAdapter,
         });
     }
-    async registerStarkEx(userAdminKeySigner, starkSigner, jwt) {
-        return withPassportError(async () => {
-            await registerPassport({
-                ethSigner: userAdminKeySigner,
-                starkSigner,
-                usersApi: this.immutableXClient.usersApi,
-            }, jwt);
-            // User metadata is updated asynchronously. Poll userinfo endpoint until it is updated.
-            const updatedUser = await retryWithDelay(async () => {
-                const user = await this.authManager.loginSilent({ forceRefresh: true }); // force refresh to get updated user info
-                const metadataExists = !!user?.imx;
-                if (metadataExists) {
-                    return user;
-                }
-                return Promise.reject(new Error('user wallet addresses not exist'));
-            });
-            return updatedUser;
-        }, PassportErrorType.REFRESH_TOKEN_ERROR);
-    }
 }
 
 const validateConfiguration = (configuration, requiredKeys, prefix) => {
@@ -33670,7 +33722,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.28.10";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.29.0";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/index.d.ts

@@ -8,16 +8,28 @@ declare class ImmutableConfiguration {
     readonly environment: Environment;
     readonly rateLimitingKey?: string;
     readonly apiKey?: string;
-    readonly clientAppId?: string;
+    readonly publishableKey?: string;
     constructor(options: {
         environment: Environment;
-        rateLimitingKey?: string;
-        apiKey?: string;
-        clientAppId?: string;
     });
 }
+declare const addApiKeyToAxiosHeader: (apiKey: string) => void;
+declare const addPublishableKeyToAxiosHeader: (publishableKey: string) => void;
+declare const addRateLimitingKeyToAxiosHeader: (rateLimitingKey: string) => void;
+type ImmutableConfigurationWithRequireableFields<T> = ImmutableConfiguration & (T extends {
+    apiKey: 'required';
+} ? Required<{
+    apiKey: string;
+}> : {}) & (T extends {
+    publishableKey: 'required';
+} ? Required<{
+    publishableKey: string;
+}> : {});
+type ImmutableConfigurationWithOmitableFields<T> = (T extends {
+    apiKey: 'omit';
+} ? Omit<ImmutableConfigurationWithRequireableFields<T>, 'apiKey'> : ImmutableConfigurationWithRequireableFields<T>);
 interface ModuleConfiguration<T> {
-    baseConfig: ImmutableConfiguration;
+    baseConfig: ImmutableConfigurationWithOmitableFields<T>;
     overrides?: T;
 }
 
@@ -26,11 +38,17 @@ declare const config_d_Environment: typeof Environment;
 type config_d_ImmutableConfiguration = ImmutableConfiguration;
 declare const config_d_ImmutableConfiguration: typeof ImmutableConfiguration;
 type config_d_ModuleConfiguration<T> = ModuleConfiguration<T>;
+declare const config_d_addApiKeyToAxiosHeader: typeof addApiKeyToAxiosHeader;
+declare const config_d_addPublishableKeyToAxiosHeader: typeof addPublishableKeyToAxiosHeader;
+declare const config_d_addRateLimitingKeyToAxiosHeader: typeof addRateLimitingKeyToAxiosHeader;
 declare namespace config_d {
   export {
     config_d_Environment as Environment,
     config_d_ImmutableConfiguration as ImmutableConfiguration,
     config_d_ModuleConfiguration as ModuleConfiguration,
+    config_d_addApiKeyToAxiosHeader as addApiKeyToAxiosHeader,
+    config_d_addPublishableKeyToAxiosHeader as addPublishableKeyToAxiosHeader,
+    config_d_addRateLimitingKeyToAxiosHeader as addRateLimitingKeyToAxiosHeader,
   };
 }