@imtbl/sdk 0.28.10 → 0.29.0-alpha.1

package/dist/orderbook.d.ts

@@ -7,16 +7,25 @@ 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;
     });
 }
+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;
 }
 

package/dist/passport.d.ts

@@ -9818,16 +9818,25 @@ 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;
     });
 }
+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;
 }
 

package/dist/passport.js

@@ -5,10 +5,10 @@ import jwt_decode from 'jwt-decode';
 import * as crypto from 'crypto';
 import { Magic } from 'magic-sdk';
 import { OpenIdExtension } from '@magic-ext/oidc';
+import { JsonRpcProvider, Web3Provider } from '@ethersproject/providers';
 import { BigNumber, ethers } from 'ethers';
 import BN from 'bn.js';
 import * as encUtils from 'enc-utils';
-import { Web3Provider, JsonRpcProvider } from '@ethersproject/providers';
 import { EventEmitter } from 'events';
 import { walletContracts } from '@0xsequence/abi';
 import { encodeSignature, decodeSignature } from '@0xsequence/config';
@@ -719,7 +719,7 @@ const CollectionsApiAxiosParamCreator = function (configuration) {
             const localVarHeaderParameter = {};
             const localVarQueryParameter = {};
             // authentication ImmutableApiKey required
-            await setApiKeyToObject(localVarHeaderParameter, "x-immutable-api-Key", configuration);
+            await setApiKeyToObject(localVarHeaderParameter, "x-immutable-api-key", configuration);
             localVarHeaderParameter['Content-Type'] = 'application/json';
             setSearchParams$1(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
@@ -2072,7 +2072,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.28.10' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-0.29.0-alpha.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -2128,7 +2128,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.28.10',
+    sdkVersion: 'ts-immutable-sdk-0.29.0-alpha.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -6766,9 +6766,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) {
@@ -6791,11 +6791,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) {
@@ -7056,7 +7056,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') {
@@ -7470,33 +7470,31 @@ async function cancelOrder({ user, starkSigner, request, ordersApi, guardianClie
 }
 
 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({ request, tradesApi, user, starkSigner, guardianClient, }) {
@@ -7642,37 +7640,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(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 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({
             request,
             user,
@@ -7681,23 +7765,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(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({
             request,
             user,
@@ -7707,7 +7789,7 @@ class PassportImxProvider {
         });
     }
     async cancelOrder(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return cancelOrder({
             request,
             user,
@@ -7717,7 +7799,7 @@ class PassportImxProvider {
         });
     }
     async createTrade(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return createTrade({
             request,
             user,
@@ -7727,7 +7809,7 @@ class PassportImxProvider {
         });
     }
     async batchNftTransfer(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return batchNftTransfer({
             request,
             user,
@@ -7737,7 +7819,7 @@ class PassportImxProvider {
         });
     }
     async exchangeTransfer(request) {
-        const { user, starkSigner } = await this.getAuthenticatedUserSigner();
+        const { user, starkSigner } = await this.getRegisteredImxUserAndSigners();
         return exchangeTransfer({
             request,
             user,
@@ -7765,7 +7847,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);
     }
 }
@@ -7825,49 +7907,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 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) => {

package/dist/provider.d.ts

@@ -917,16 +917,25 @@ 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;
     });
 }
+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;
 }
 

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "0.28.10",
+  "version": "0.29.0-alpha.1",
   "author": "Immutable",
   "browser": "./dist/index.browser.js",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
   "dependencies": {
     "@0xsequence/abi": "^0.43.34",
     "@0xsequence/config": "^0.43.34",
+    "@biom3/design-tokens": "0.2.4-beta",
+    "@biom3/react": "^0.10.12",
     "@ethersproject/abi": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
     "@ethersproject/providers": "^5.7.2",
     "@ethersproject/wallet": "^5.7.0",
     "@imtbl/core-sdk": "^2.4.0",
+    "@imtbl/react-analytics": "0.2.1-alpha",
     "@jest/globals": "^29.5.0",
     "@magic-ext/oidc": "^4.2.0",
     "@metamask/detect-provider": "^2.0.0",
@@ -20,13 +23,25 @@
     "@uniswap/router-sdk": "^1.4.0",
     "@uniswap/sdk-core": "^3.0.1",
     "@uniswap/v3-sdk": "^3.9.0",
+    "assert": "^2.0.0",
     "axios": "^1.3.5",
     "bn.js": "^5.2.1",
+    "buffer": "^6.0.3",
+    "crypto-browserify": "^3.12.0",
     "enc-utils": "^3.0.0",
     "ethers": "^5.7.2",
+    "https-browserify": "^1.0.0",
     "jwt-decode": "^3.1.2",
     "magic-sdk": "^21.2.0",
-    "oidc-client-ts": "^2.2.1"
+    "oidc-client-ts": "^2.2.1",
+    "os-browserify": "^0.3.0",
+    "pako": "^2.1.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.11.0",
+    "stream-browserify": "^3.0.0",
+    "stream-http": "^3.2.0",
+    "url": "^0.11.0"
   },
   "devDependencies": {
     "@imtbl/blockchain-data": "0.0.0",
@@ -94,10 +109,6 @@
     "./checkout_sdk": {
       "types": "./dist/checkout_sdk.d.ts",
       "import": "./dist/checkout_sdk.js"
-    },
-    "./checkout_widgets": {
-      "types": "./dist/checkout_widgets.d.ts",
-      "import": "./dist/checkout_widgets.js"
     }
   },
   "files": [