@imtbl/sdk 1.7.3 → 1.8.0

package/dist/passport.js

@@ -9146,7 +9146,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.7.3' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.8.0' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -9325,7 +9325,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.7.3';
+const SDK_VERSION = '1.8.0';
 const getReferrer = () => {
     if (isNode()) {
         return '';
@@ -9538,7 +9538,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.7.3',
+    sdkVersion: 'ts-immutable-sdk-1.8.0',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -14176,7 +14176,6 @@ const getAuthConfiguration = (config) => {
             end_session_endpoint: endSessionEndpoint,
         },
         mergeClaims: true,
-        loadUserInfo: true,
         scope: oidcConfiguration.scope,
         userStore,
     };
@@ -14217,7 +14216,10 @@ class AuthManager {
         this.logoutMode = config.oidcConfiguration.logoutMode || 'redirect';
     }
     static mapOidcUserToDomainModel = (oidcUser) => {
-        const passport = oidcUser.profile?.passport;
+        let passport;
+        if (oidcUser.id_token) {
+            passport = jwt_decode(oidcUser.id_token)?.passport;
+        }
         const user = {
             expired: oidcUser.expired,
             idToken: oidcUser.id_token,
@@ -15642,27 +15644,28 @@ class JsonRpcError extends Error {
 }
 
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
-    const web3Provider = new Web3Provider(magicProvider);
-    const ethSigner = web3Provider.getSigner();
-    const ethereumAddress = await ethSigner.getAddress();
-    const ethereumSignature = await signRaw(MESSAGE_TO_SIGN, ethSigner);
-    const headers = { Authorization: `Bearer ${accessToken}` };
-    const { chainId } = await jsonRpcProvider.ready;
-    const eipChainId = getEip155ChainId(chainId);
+async function registerZkEvmUser({ authManager, ethSigner, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
+    const [ethereumAddress, ethereumSignature, network, chainListResponse] = await Promise.all([
+        ethSigner.getAddress(),
+        signRaw(MESSAGE_TO_SIGN, ethSigner),
+        jsonRpcProvider.ready,
+        multiRollupApiClients.chainsApi.listChains(),
+    ]);
+    const eipChainId = getEip155ChainId(network.chainId);
+    const chainName = chainListResponse.data?.result?.find((chain) => chain.id === eipChainId)?.name;
+    if (!chainName) {
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Chain name does not exist on for chain id ${network.chainId}`);
+    }
     try {
-        const chainList = (await multiRollupApiClients.chainsApi.listChains()).data.result;
-        const chainName = chainList.find((chain) => chain.id === eipChainId)?.name;
-        if (!chainName) {
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Chain name does not exist on for chain id ${chainId}`);
-        }
         await multiRollupApiClients.passportApi.createCounterfactualAddressV2({
             chainName,
             createCounterfactualAddressRequest: {
                 ethereum_address: ethereumAddress,
                 ethereum_signature: ethereumSignature,
             },
-        }, { headers });
+        }, {
+            headers: { Authorization: `Bearer ${accessToken}` },
+        });
     }
     catch (error) {
         throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Failed to create counterfactual address: ${error}`);
@@ -15674,32 +15677,6 @@ async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiCli
     return user;
 }
 
-const loginZkEvmUser = async ({ authManager, magicAdapter, multiRollupApiClients, jsonRpcProvider, }) => {
-    const user = await authManager.getUserOrLogin();
-    if (!user.idToken) {
-        throw new Error('User is missing idToken');
-    }
-    const magicProvider = await magicAdapter.login(user.idToken);
-    if (!user.zkEvm) {
-        // Generate counterfactual address and retrieve updated Auth0 user
-        const userZkevm = await registerZkEvmUser({
-            authManager,
-            magicProvider,
-            multiRollupApiClients,
-            accessToken: user.accessToken,
-            jsonRpcProvider,
-        });
-        return {
-            user: userZkevm,
-            magicProvider,
-        };
-    }
-    return {
-        user: user,
-        magicProvider,
-    };
-};
-
 const transactionRejectedCrossSdkBridgeError = 'Transaction requires confirmation but this functionality is not'
     + ' supported in this environment. Please contact Immutable support if you need to enable this feature.';
 const convertBigNumberishToString = (value) => BigNumber.from(value).toString();
@@ -15895,7 +15872,7 @@ const getMetaTransactions = async (metaTransaction, nonce, chainId, walletAddres
     }
     return [metaTransaction, feeMetaTransaction];
 };
-const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient, guardianClient, zkevmAddress, }) => guardianClient
+const sendTransaction = ({ params, ethSigner, jsonRpcProvider, relayerClient, guardianClient, zkevmAddress, }) => guardianClient
     .withConfirmationScreen({ width: 480, height: 720 })(async () => {
     const transactionRequest = params[0];
     if (!transactionRequest.to) {
@@ -15903,8 +15880,6 @@ const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient
     }
     const { chainId } = await jsonRpcProvider.ready;
     const chainIdBigNumber = BigNumber.from(chainId);
-    const magicWeb3Provider = new Web3Provider(magicProvider);
-    const signer = magicWeb3Provider.getSigner();
     const nonce = await getNonce(jsonRpcProvider, zkevmAddress);
     const metaTransaction = {
         to: transactionRequest.to,
@@ -15913,15 +15888,18 @@ const sendTransaction = ({ params, magicProvider, jsonRpcProvider, relayerClient
         value: transactionRequest.value,
         revertOnError: true,
     };
-    const metaTransactions = await getMetaTransactions(metaTransaction, nonce, chainIdBigNumber, zkevmAddress, signer, relayerClient);
-    await guardianClient.validateEVMTransaction({
-        chainId: getEip155ChainId(chainId),
-        nonce: convertBigNumberishToString(nonce),
-        metaTransactions,
-    });
-    // NOTE: We sign again because we now are adding the fee transaction, so the
-    // whole payload is different and needs a new signature.
-    const signedTransactions = await getSignedMetaTransactions(metaTransactions, nonce, chainIdBigNumber, zkevmAddress, signer);
+    const metaTransactions = await getMetaTransactions(metaTransaction, nonce, chainIdBigNumber, zkevmAddress, ethSigner, relayerClient);
+    // Parallelize the validation and signing of the transaction
+    const [, signedTransactions] = await Promise.all([
+        guardianClient.validateEVMTransaction({
+            chainId: getEip155ChainId(chainId),
+            nonce: convertBigNumberishToString(nonce),
+            metaTransactions,
+        }),
+        // NOTE: We sign again because we now are adding the fee transaction, so the
+        // whole payload is different and needs a new signature.
+        getSignedMetaTransactions(metaTransactions, nonce, chainIdBigNumber, zkevmAddress, ethSigner),
+    ]);
     const relayerId = await relayerClient.ethSendTransaction(zkevmAddress, signedTransactions);
     const retrieveRelayerTransaction = async () => {
         const tx = await relayerClient.imGetTransactionByHash(relayerId);
@@ -15990,7 +15968,7 @@ const transformTypedData = (typedData, chainId) => {
     }
     return transformedTypedData;
 };
-const signTypedDataV4 = async ({ params, method, magicProvider, jsonRpcProvider, relayerClient, guardianClient, }) => guardianClient
+const signTypedDataV4 = async ({ params, method, ethSigner, jsonRpcProvider, relayerClient, guardianClient, }) => guardianClient
     .withConfirmationScreen({ width: 480, height: 720 })(async () => {
     const fromAddress = params[0];
     const typedDataParam = params[1];
@@ -16001,106 +15979,158 @@ const signTypedDataV4 = async ({ params, method, magicProvider, jsonRpcProvider,
     const typedData = transformTypedData(typedDataParam, chainId);
     await guardianClient.validateMessage({ chainID: String(chainId), payload: typedData });
     const relayerSignature = await relayerClient.imSignTypedData(fromAddress, typedData);
-    const magicWeb3Provider = new Web3Provider(magicProvider);
-    const signer = magicWeb3Provider.getSigner();
-    return getSignedTypedData(typedData, relayerSignature, BigNumber.from(chainId), fromAddress, signer);
+    return getSignedTypedData(typedData, relayerSignature, BigNumber.from(chainId), fromAddress, ethSigner);
 });
 
+const isZkEvmUser = (user) => 'zkEvm' in user;
 class ZkEvmProvider {
-    authManager;
-    config;
-    magicAdapter;
-    multiRollupApiClients;
-    jsonRpcProvider; // Used for read
-    eventEmitter;
-    guardianClient;
-    relayerClient;
-    magicProvider; // Used for signing
-    zkevmAddress;
+    #authManager;
+    #config;
+    #eventEmitter;
+    #guardianClient;
+    #jsonRpcProvider; // Used for read
+    #magicAdapter;
+    #multiRollupApiClients;
+    #relayerClient;
+    /**
+     * This property is set during `#initialiseEthSigner` and stores the signer in a promise.
+     * This property is not meant to be accessed directly, but through the
+     * `#getSigner` method.
+     * @see getSigner
+     */
+    #ethSigner;
+    #signerInitialisationError;
+    #zkEvmAddress;
     isPassport = true;
     constructor({ authManager, magicAdapter, config, multiRollupApiClients, passportEventEmitter, guardianClient, }) {
-        this.authManager = authManager;
-        this.magicAdapter = magicAdapter;
-        this.config = config;
-        this.guardianClient = guardianClient;
+        this.#authManager = authManager;
+        this.#magicAdapter = magicAdapter;
+        this.#config = config;
+        this.#guardianClient = guardianClient;
         if (config.crossSdkBridgeEnabled) {
             // JsonRpcProvider by default sets the referrer as "client".
             // On Unreal 4 this errors as the browser used is expecting a valid URL.
-            this.jsonRpcProvider = new JsonRpcProvider({
-                url: this.config.zkEvmRpcUrl,
+            this.#jsonRpcProvider = new JsonRpcProvider({
+                url: this.#config.zkEvmRpcUrl,
                 fetchOptions: { referrer: 'http://imtblgamesdk.local' },
             });
         }
         else {
-            this.jsonRpcProvider = new JsonRpcProvider(this.config.zkEvmRpcUrl);
+            this.#jsonRpcProvider = new JsonRpcProvider(this.#config.zkEvmRpcUrl);
         }
-        this.multiRollupApiClients = multiRollupApiClients;
-        this.eventEmitter = new TypedEventEmitter();
-        passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
-    }
-    handleLogout = () => {
-        const shouldEmitAccountsChanged = this.isLoggedIn();
-        this.magicProvider = undefined;
-        this.relayerClient = undefined;
+        this.#relayerClient = new RelayerClient({
+            config: this.#config,
+            jsonRpcProvider: this.#jsonRpcProvider,
+            authManager: this.#authManager,
+        });
+        this.#multiRollupApiClients = multiRollupApiClients;
+        this.#eventEmitter = new TypedEventEmitter();
+        passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.#handleLogout);
+    }
+    #handleLogout = () => {
+        const shouldEmitAccountsChanged = !!this.#zkEvmAddress;
+        this.#ethSigner = undefined;
+        this.#zkEvmAddress = undefined;
         if (shouldEmitAccountsChanged) {
-            this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
+            this.#eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
         }
     };
-    isLoggedIn() {
-        return this.magicProvider !== undefined
-            && this.zkevmAddress !== undefined
-            && this.relayerClient !== undefined;
+    /**
+     * This method is called by `eth_requestAccounts` and asynchronously initialises the signer.
+     * The signer is stored in a promise so that it 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 signer is requested through:
+     * @see #getSigner
+     *
+     */
+    async #initialiseEthSigner(user) {
+        const generateSigner = async () => {
+            const magicRpcProvider = await this.#magicAdapter.login(user.idToken);
+            const web3Provider = new Web3Provider(magicRpcProvider);
+            return web3Provider.getSigner();
+        };
+        // eslint-disable-next-line no-async-promise-executor
+        this.#ethSigner = new Promise(async (resolve) => {
+            try {
+                resolve(await generateSigner());
+            }
+            catch (err) {
+                // Capture and store the initialization error
+                this.#signerInitialisationError = err;
+                resolve(undefined);
+            }
+        });
     }
-    async performRequest(request) {
+    async #getSigner() {
+        const ethSigner = await this.#ethSigner;
+        // Throw the stored error if the signers failed to initialise
+        if (typeof ethSigner === 'undefined') {
+            if (typeof this.#signerInitialisationError !== 'undefined') {
+                throw this.#signerInitialisationError;
+            }
+            throw new Error('Signer failed to initialise');
+        }
+        return ethSigner;
+    }
+    async #performRequest(request) {
         switch (request.method) {
             case 'eth_requestAccounts': {
-                if (this.isLoggedIn()) {
-                    return [this.zkevmAddress];
+                if (this.#zkEvmAddress) {
+                    return [this.#zkEvmAddress];
                 }
-                const { magicProvider, user } = await loginZkEvmUser({
-                    authManager: this.authManager,
-                    magicAdapter: this.magicAdapter,
-                    multiRollupApiClients: this.multiRollupApiClients,
-                    jsonRpcProvider: this.jsonRpcProvider,
-                });
-                this.magicProvider = magicProvider;
-                this.relayerClient = new RelayerClient({
-                    config: this.config,
-                    jsonRpcProvider: this.jsonRpcProvider,
-                    authManager: this.authManager,
-                });
-                this.zkevmAddress = user.zkEvm.ethAddress;
-                this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [user.zkEvm.ethAddress]);
-                return [user.zkEvm.ethAddress];
+                const user = await this.#authManager.getUserOrLogin();
+                this.#initialiseEthSigner(user);
+                if (!isZkEvmUser(user)) {
+                    const ethSigner = await this.#getSigner();
+                    const userZkEvm = await registerZkEvmUser({
+                        ethSigner,
+                        authManager: this.#authManager,
+                        multiRollupApiClients: this.#multiRollupApiClients,
+                        accessToken: user.accessToken,
+                        jsonRpcProvider: this.#jsonRpcProvider,
+                    });
+                    this.#zkEvmAddress = userZkEvm.zkEvm.ethAddress;
+                }
+                else {
+                    this.#zkEvmAddress = user.zkEvm.ethAddress;
+                }
+                this.#eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.#zkEvmAddress]);
+                return [this.#zkEvmAddress];
             }
             case 'eth_sendTransaction': {
-                if (!this.isLoggedIn()) {
+                if (!this.#zkEvmAddress) {
                     throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
                 }
+                const ethSigner = await this.#getSigner();
                 return sendTransaction({
                     params: request.params || [],
-                    magicProvider: this.magicProvider,
-                    guardianClient: this.guardianClient,
-                    jsonRpcProvider: this.jsonRpcProvider,
-                    relayerClient: this.relayerClient,
-                    zkevmAddress: this.zkevmAddress,
+                    ethSigner,
+                    guardianClient: this.#guardianClient,
+                    jsonRpcProvider: this.#jsonRpcProvider,
+                    relayerClient: this.#relayerClient,
+                    zkevmAddress: this.#zkEvmAddress,
                 });
             }
             case 'eth_accounts': {
-                return this.zkevmAddress ? [this.zkevmAddress] : [];
+                return this.#zkEvmAddress ? [this.#zkEvmAddress] : [];
             }
             case 'eth_signTypedData':
             case 'eth_signTypedData_v4': {
-                if (!this.isLoggedIn()) {
+                if (!this.#zkEvmAddress) {
                     throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
                 }
+                const ethSigner = await this.#getSigner();
                 return signTypedDataV4({
                     method: request.method,
                     params: request.params || [],
-                    magicProvider: this.magicProvider,
-                    jsonRpcProvider: this.jsonRpcProvider,
-                    relayerClient: this.relayerClient,
-                    guardianClient: this.guardianClient,
+                    ethSigner,
+                    jsonRpcProvider: this.#jsonRpcProvider,
+                    relayerClient: this.#relayerClient,
+                    guardianClient: this.#guardianClient,
                 });
             }
             // Pass through methods
@@ -16117,17 +16147,17 @@ class ZkEvmProvider {
             case 'eth_getTransactionByHash':
             case 'eth_getTransactionReceipt':
             case 'eth_getTransactionCount': {
-                return this.jsonRpcProvider.send(request.method, request.params || []);
+                return this.#jsonRpcProvider.send(request.method, request.params || []);
             }
             default: {
                 throw new JsonRpcError(ProviderErrorCode.UNSUPPORTED_METHOD, 'Method not supported');
             }
         }
     }
-    async performJsonRpcRequest(request) {
+    async #performJsonRpcRequest(request) {
         const { id, jsonrpc } = request;
         try {
-            const result = await this.performRequest(request);
+            const result = await this.#performRequest(request);
             return {
                 id,
                 jsonrpc,
@@ -16154,7 +16184,7 @@ class ZkEvmProvider {
     }
     async request(request) {
         try {
-            return this.performRequest(request);
+            return this.#performRequest(request);
         }
         catch (error) {
             if (error instanceof JsonRpcError) {
@@ -16171,14 +16201,14 @@ class ZkEvmProvider {
             throw new Error('No callback provided');
         }
         if (Array.isArray(request)) {
-            Promise.all(request.map(this.performJsonRpcRequest)).then((result) => {
+            Promise.all(request.map(this.#performJsonRpcRequest)).then((result) => {
                 callback(null, result);
             }).catch((error) => {
                 callback(error, []);
             });
         }
         else {
-            this.performJsonRpcRequest(request).then((result) => {
+            this.#performJsonRpcRequest(request).then((result) => {
                 callback(null, result);
             }).catch((error) => {
                 callback(error, null);
@@ -16210,15 +16240,15 @@ class ZkEvmProvider {
             return this.sendAsync(request, callbackOrParams);
         }
         if (!Array.isArray(request) && typeof request === 'object') {
-            return this.performJsonRpcRequest(request);
+            return this.#performJsonRpcRequest(request);
         }
         throw new JsonRpcError(RpcErrorCode.INVALID_REQUEST, 'Invalid request');
     }
     on(event, listener) {
-        this.eventEmitter.on(event, listener);
+        this.#eventEmitter.on(event, listener);
     }
     removeListener(event, listener) {
-        this.eventEmitter.removeListener(event, listener);
+        this.#eventEmitter.removeListener(event, listener);
     }
 }
 

package/dist/x.js

@@ -136,7 +136,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.7.3';
+const SDK_VERSION = '1.8.0';
 const getReferrer = () => {
     if (isNode()) {
         return '';
@@ -328,7 +328,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.7.3',
+    sdkVersion: 'ts-immutable-sdk-1.8.0',
 });
 /**
  * Sets `sdkVersion` at the time of build

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imtbl/sdk",
   "description": "Immutable Unified SDK",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "author": "Immutable",
   "browser": "./dist/index.browser.js",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",