@imtbl/sdk 1.6.1 → 1.7.1

package/dist/passport.js

@@ -8,10 +8,10 @@ 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 { EventEmitter } from 'events';
+import { BigNumber, ethers } from 'ethers';
 import { walletContracts } from '@0xsequence/abi';
 import { v1 } from '@0xsequence/core';
 
@@ -9146,7 +9146,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.6.1' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.7.1' };
 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.6.1';
+const SDK_VERSION = '1.7.1';
 const getReferrer = () => {
     if (isNode()) {
         return '';
@@ -9537,7 +9537,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.6.1',
+    sdkVersion: 'ts-immutable-sdk-1.7.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -10040,6 +10040,69 @@ class IMXClient {
     }
 }
 
+// used to sign message with L1 keys. Used for registration
+function serializeEthSignature(sig) {
+    // This is because golang appends a recovery param
+    // https://github.com/ethers-io/ethers.js/issues/823
+    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64)
+        + encUtils.padLeft(sig.s.toString(16), 64)
+        + encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
+}
+function importRecoveryParam(v) {
+    const isValidBigNumber = new BN(v, 16).cmp(new BN(27)) !== -1
+        ? new BN(v, 16).sub(new BN(27)).toNumber()
+        : new BN(v, 16).toNumber();
+    return v.trim()
+        ? isValidBigNumber
+        : undefined;
+}
+// used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
+function deserializeSignature(sig, size = 64) {
+    const removedHexPrefixSig = encUtils.removeHexPrefix(sig);
+    return {
+        r: new BN(removedHexPrefixSig.substring(0, size), 'hex'),
+        s: new BN(removedHexPrefixSig.substring(size, size * 2), 'hex'),
+        recoveryParam: importRecoveryParam(removedHexPrefixSig.substring(size * 2, size * 2 + 2)),
+    };
+}
+async function signRaw(payload, signer) {
+    const signature = deserializeSignature(await signer.signMessage(payload));
+    return serializeEthSignature(signature);
+}
+
+/**
+ * Helper method to convert token type to a SignableToken type
+ * @param token - the token type to convert to a SignableToken type
+ * @returns the converted SignableToken
+ */
+function convertToSignableToken(token) {
+    switch (token.type) {
+        case 'ERC721':
+            return {
+                type: 'ERC721',
+                data: {
+                    token_id: token.tokenId,
+                    token_address: token.tokenAddress,
+                },
+            };
+        case 'ERC20':
+            return {
+                type: 'ERC20',
+                data: {
+                    token_address: token.tokenAddress,
+                },
+            };
+        case 'ETH':
+        default:
+            return {
+                type: 'ETH',
+                data: {
+                    decimals: 18,
+                },
+            };
+    }
+}
+
 function bind(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -13955,69 +14018,6 @@ const TransactionApprovalRequestChainTypeEnum = {
     Evm: 'evm'
 };
 
-// used to sign message with L1 keys. Used for registration
-function serializeEthSignature(sig) {
-    // This is because golang appends a recovery param
-    // https://github.com/ethers-io/ethers.js/issues/823
-    return encUtils.addHexPrefix(encUtils.padLeft(sig.r.toString(16), 64)
-        + encUtils.padLeft(sig.s.toString(16), 64)
-        + encUtils.padLeft(sig.recoveryParam?.toString(16) || '', 2));
-}
-function importRecoveryParam(v) {
-    const isValidBigNumber = new BN(v, 16).cmp(new BN(27)) !== -1
-        ? new BN(v, 16).sub(new BN(27)).toNumber()
-        : new BN(v, 16).toNumber();
-    return v.trim()
-        ? isValidBigNumber
-        : undefined;
-}
-// used chained with serializeEthSignature. serializeEthSignature(deserializeSignature(...))
-function deserializeSignature(sig, size = 64) {
-    const removedHexPrefixSig = encUtils.removeHexPrefix(sig);
-    return {
-        r: new BN(removedHexPrefixSig.substring(0, size), 'hex'),
-        s: new BN(removedHexPrefixSig.substring(size, size * 2), 'hex'),
-        recoveryParam: importRecoveryParam(removedHexPrefixSig.substring(size * 2, size * 2 + 2)),
-    };
-}
-async function signRaw(payload, signer) {
-    const signature = deserializeSignature(await signer.signMessage(payload));
-    return serializeEthSignature(signature);
-}
-
-/**
- * Helper method to convert token type to a SignableToken type
- * @param token - the token type to convert to a SignableToken type
- * @returns the converted SignableToken
- */
-function convertToSignableToken(token) {
-    switch (token.type) {
-        case 'ERC721':
-            return {
-                type: 'ERC721',
-                data: {
-                    token_id: token.tokenId,
-                    token_address: token.tokenAddress,
-                },
-            };
-        case 'ERC20':
-            return {
-                type: 'ERC20',
-                data: {
-                    token_address: token.tokenAddress,
-                },
-            };
-        case 'ETH':
-        default:
-            return {
-                type: 'ETH',
-                data: {
-                    decimals: 18,
-                },
-            };
-    }
-}
-
 var PassportErrorType;
 (function (PassportErrorType) {
     PassportErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
@@ -14271,6 +14271,17 @@ class AuthManager {
             return AuthManager.mapOidcUserToDomainModel(oidcUser);
         }, PassportErrorType.AUTHENTICATION_ERROR);
     }
+    async getUserOrLogin() {
+        let user = null;
+        try {
+            user = await this.getUser();
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn('failed to retrieve a cached user session:', err);
+        }
+        return user || this.login();
+    }
     async loginCallback() {
         return withPassportError(async () => this.userManager.signinPopupCallback(), PassportErrorType.AUTHENTICATION_ERROR);
     }
@@ -14518,274 +14529,53 @@ const getStarkSigner = async (signer) => withPassportError(async () => {
     return createStarkSigner(privateKey);
 }, PassportErrorType.WALLET_CONNECTION_ERROR);
 
-const POLL_INTERVAL = 1 * 1000; // every 1 second
-const MAX_RETRIES = 3;
-const wait = (ms) => new Promise((resolve) => {
-    setTimeout(() => resolve(), ms);
-});
-const retryWithDelay = async (fn, options) => {
-    const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), finallyFn = () => { }, } = options || {};
-    try {
-        return await fn();
-    }
-    catch (err) {
-        if (retries <= 0) {
-            return Promise.reject(finalErr);
-        }
-        await wait(interval);
-        return retryWithDelay(fn, { retries: retries - 1, finalErr, finallyFn });
-    }
-    finally {
-        if (retries <= 0) {
-            finallyFn();
-        }
-    }
-};
+var PassportEvents;
+(function (PassportEvents) {
+    PassportEvents["LOGGED_OUT"] = "loggedOut";
+})(PassportEvents || (PassportEvents = {}));
 
-/**
- * ProviderErrors should take priority over RpcErrorCodes
- * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
- * https://eips.ethereum.org/EIPS/eip-1474#error-codes
- */
-var ProviderErrorCode;
-(function (ProviderErrorCode) {
-    ProviderErrorCode[ProviderErrorCode["USER_REJECTED_REQUEST"] = 4001] = "USER_REJECTED_REQUEST";
-    ProviderErrorCode[ProviderErrorCode["UNAUTHORIZED"] = 4100] = "UNAUTHORIZED";
-    ProviderErrorCode[ProviderErrorCode["UNSUPPORTED_METHOD"] = 4200] = "UNSUPPORTED_METHOD";
-    ProviderErrorCode[ProviderErrorCode["DISCONNECTED"] = 4900] = "DISCONNECTED";
-})(ProviderErrorCode || (ProviderErrorCode = {}));
-var RpcErrorCode;
-(function (RpcErrorCode) {
-    RpcErrorCode[RpcErrorCode["RPC_SERVER_ERROR"] = -32000] = "RPC_SERVER_ERROR";
-    RpcErrorCode[RpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-    RpcErrorCode[RpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-    RpcErrorCode[RpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-    RpcErrorCode[RpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-    RpcErrorCode[RpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-    RpcErrorCode[RpcErrorCode["TRANSACTION_REJECTED"] = -32003] = "TRANSACTION_REJECTED";
-})(RpcErrorCode || (RpcErrorCode = {}));
-class JsonRpcError extends Error {
-    message;
-    code;
-    constructor(code, message) {
-        super(message);
-        this.message = message;
-        this.code = code;
-    }
-}
-
-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();
-const transformGuardianTransactions = (txs) => {
-    try {
-        return txs.map((t) => ({
-            delegateCall: t.delegateCall === true,
-            revertOnError: t.revertOnError === true,
-            gasLimit: t.gasLimit ? convertBigNumberishToString(t.gasLimit) : '0',
-            target: t.to ?? ethers.constants.AddressZero,
-            value: t.value ? convertBigNumberishToString(t.value) : '0',
-            data: t.data ? t.data.toString() : '0x',
-        }));
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Transaction failed to parsing: ${errorMessage}`);
-    }
-};
-class GuardianClient {
-    transactionAPI;
-    messageAPI;
-    confirmationScreen;
-    crossSdkBridgeEnabled;
-    authManager;
-    constructor({ confirmationScreen, config, authManager }) {
-        const guardianConfiguration = new Configuration({ basePath: config.imxPublicApiDomain });
-        this.confirmationScreen = confirmationScreen;
-        this.crossSdkBridgeEnabled = config.crossSdkBridgeEnabled;
-        this.messageAPI = new MessagesApi(guardianConfiguration);
-        this.transactionAPI = new TransactionsApi(guardianConfiguration);
-        this.authManager = authManager;
-    }
-    /**
-     * Open confirmation screen and close it automatically if the
-     * underlying task fails.
-     */
-    withConfirmationScreen(popupWindowSize) {
-        return (task) => this.withConfirmationScreenTask(popupWindowSize)(task)();
-    }
-    withConfirmationScreenTask(popupWindowSize) {
-        return (task) => async () => {
-            this.confirmationScreen.loading(popupWindowSize);
-            try {
-                return await task();
-            }
-            catch (err) {
-                this.confirmationScreen.closeWindow();
-                throw err;
-            }
-        };
-    }
-    withDefaultConfirmationScreenTask(task) {
-        return this.withConfirmationScreenTask()(task);
-    }
-    async evaluateImxTransaction({ payloadHash }) {
-        const finallyFn = () => {
-            this.confirmationScreen.closeWindow();
-        };
-        const user = await this.authManager.getUser();
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
-        const transactionRes = await retryWithDelay(async () => this.transactionAPI.getTransactionByID({
-            transactionID: payloadHash,
-            chainType: 'starkex',
-        }, { headers }), { finallyFn });
-        if (!transactionRes.data.id) {
-            throw new Error("Transaction doesn't exists");
-        }
-        const evaluateImxRes = await this.transactionAPI.evaluateTransaction({
-            id: payloadHash,
-            transactionEvaluationRequest: {
-                chainType: 'starkex',
-            },
-        }, { headers });
-        const { confirmationRequired } = evaluateImxRes.data;
-        if (confirmationRequired) {
-            if (this.crossSdkBridgeEnabled) {
-                throw new Error(transactionRejectedCrossSdkBridgeError);
-            }
-            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, user.imx.ethAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
-            if (!confirmationResult.confirmed) {
-                throw new Error('Transaction rejected by user');
-            }
-        }
-        else {
-            this.confirmationScreen.closeWindow();
-        }
-    }
-    async evaluateEVMTransaction({ chainId, nonce, metaTransactions, }) {
-        const user = await this.authManager.getUser();
-        const headers = { Authorization: `Bearer ${user.accessToken}` };
-        const guardianTransactions = transformGuardianTransactions(metaTransactions);
-        try {
-            const transactionEvaluationResponseAxiosResponse = await this.transactionAPI.evaluateTransaction({
-                id: 'evm',
-                transactionEvaluationRequest: {
-                    chainType: 'evm',
-                    chainId,
-                    transactionData: {
-                        nonce,
-                        userAddress: user.zkEvm.ethAddress,
-                        metaTransactions: guardianTransactions,
-                    },
-                },
-            }, { headers });
-            return transactionEvaluationResponseAxiosResponse.data;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Transaction failed to validate with error: ${errorMessage}`);
-        }
-    }
-    async validateEVMTransaction({ chainId, nonce, metaTransactions, }) {
-        const transactionEvaluationResponse = await this.evaluateEVMTransaction({
-            chainId,
-            nonce,
-            metaTransactions,
-        });
-        const { confirmationRequired, transactionId } = transactionEvaluationResponse;
-        if (confirmationRequired && this.crossSdkBridgeEnabled) {
-            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
-        }
-        if (confirmationRequired && !!transactionId) {
-            const user = await this.authManager.getUser();
-            const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, user.zkEvm.ethAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
-            if (!confirmationResult.confirmed) {
-                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Transaction rejected by user');
-            }
-        }
-        else {
-            this.confirmationScreen.closeWindow();
-        }
-    }
-    async evaluateMessage({ chainID, payload }) {
-        try {
-            const user = await this.authManager.getUser();
-            if (user === null) {
-                throw new PassportError('evaluateMessage requires a valid ID token or refresh token. Please log in first', PassportErrorType.NOT_LOGGED_IN_ERROR);
-            }
-            const messageEvalResponse = await this.messageAPI.evaluateMessage({ messageEvaluationRequest: { chainID, payload } }, { headers: { Authorization: `Bearer ${user.accessToken}` } });
-            return messageEvalResponse.data;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Message failed to validate with error: ${errorMessage}`);
-        }
-    }
-    async validateMessage({ chainID, payload }) {
-        const { messageId, confirmationRequired } = await this.evaluateMessage({ chainID, payload });
-        if (confirmationRequired && this.crossSdkBridgeEnabled) {
-            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
-        }
-        if (confirmationRequired && !!messageId) {
-            const user = await this.authManager.getUser();
-            const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress);
-            if (!confirmationResult.confirmed) {
-                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
-            }
-        }
-        else {
-            this.confirmationScreen.closeWindow();
-        }
-    }
-}
-
-var PassportEvents;
-(function (PassportEvents) {
-    PassportEvents["LOGGED_OUT"] = "loggedOut";
-})(PassportEvents || (PassportEvents = {}));
-
-async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
-    return withPassportError(async () => {
-        const { ethAddress } = user.imx;
-        const transferAmount = request.amount;
-        const signableResult = await exchangesApi.getExchangeSignableTransfer({
-            id: request.transactionID,
-            getSignableTransferRequest: {
-                sender: ethAddress,
-                token: convertToSignableToken(request),
-                amount: transferAmount,
-                receiver: request.receiver,
-            },
-        });
-        const starkAddress = await starkSigner.getAddress();
-        const { payload_hash: payloadHash } = signableResult.data;
-        const starkSignature = await starkSigner.signMessage(payloadHash);
-        const transferSigningParams = {
-            sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
-            sender_vault_id: signableResult.data.sender_vault_id,
-            receiver_stark_key: signableResult.data.receiver_stark_key,
-            receiver_vault_id: signableResult.data.receiver_vault_id,
-            asset_id: signableResult.data.asset_id,
-            amount: signableResult.data.amount,
-            nonce: signableResult.data.nonce,
-            expiration_timestamp: signableResult.data.expiration_timestamp,
-            stark_signature: starkSignature,
-        };
-        const headers = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            Authorization: `Bearer ${user.accessToken}`,
-        };
-        const response = await exchangesApi.createExchangeTransfer({
-            id: request.transactionID,
-            createTransferRequest: transferSigningParams,
-        }, { headers });
-        return {
-            sent_signature: response?.data.sent_signature,
-            status: response?.data.status?.toString(),
-            time: response?.data.time,
-            transfer_id: response?.data.transfer_id,
-        };
-    }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
+async function exchangeTransfer({ user, starkSigner, request, exchangesApi, }) {
+    return withPassportError(async () => {
+        const { ethAddress } = user.imx;
+        const transferAmount = request.amount;
+        const signableResult = await exchangesApi.getExchangeSignableTransfer({
+            id: request.transactionID,
+            getSignableTransferRequest: {
+                sender: ethAddress,
+                token: convertToSignableToken(request),
+                amount: transferAmount,
+                receiver: request.receiver,
+            },
+        });
+        const starkAddress = await starkSigner.getAddress();
+        const { payload_hash: payloadHash } = signableResult.data;
+        const starkSignature = await starkSigner.signMessage(payloadHash);
+        const transferSigningParams = {
+            sender_stark_key: signableResult.data.sender_stark_key || starkAddress,
+            sender_vault_id: signableResult.data.sender_vault_id,
+            receiver_stark_key: signableResult.data.receiver_stark_key,
+            receiver_vault_id: signableResult.data.receiver_vault_id,
+            asset_id: signableResult.data.asset_id,
+            amount: signableResult.data.amount,
+            nonce: signableResult.data.nonce,
+            expiration_timestamp: signableResult.data.expiration_timestamp,
+            stark_signature: starkSignature,
+        };
+        const headers = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Authorization: `Bearer ${user.accessToken}`,
+        };
+        const response = await exchangesApi.createExchangeTransfer({
+            id: request.transactionID,
+            createTransferRequest: transferSigningParams,
+        }, { headers });
+        return {
+            sent_signature: response?.data.sent_signature,
+            status: response?.data.status?.toString(),
+            time: response?.data.time,
+            transfer_id: response?.data.transfer_id,
+        };
+    }, PassportErrorType.EXCHANGE_TRANSFER_ERROR);
 }
 
 const ERC721$1 = 'ERC721';
@@ -15037,6 +14827,30 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
     }), PassportErrorType.TRANSFER_ERROR);
 }
 
+const POLL_INTERVAL = 1 * 1000; // every 1 second
+const MAX_RETRIES = 3;
+const wait = (ms) => new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+});
+const retryWithDelay = async (fn, options) => {
+    const { retries = MAX_RETRIES, interval = POLL_INTERVAL, finalErr = Error('Retry failed'), finallyFn = () => { }, } = options || {};
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (retries <= 0) {
+            return Promise.reject(finalErr);
+        }
+        await wait(interval);
+        return retryWithDelay(fn, { retries: retries - 1, finalErr, finallyFn });
+    }
+    finally {
+        if (retries <= 0) {
+            finallyFn();
+        }
+    }
+};
+
 async function forceUserRefresh(authManager) {
     // User metadata is updated asynchronously. Poll userinfo endpoint until it is updated.
     await retryWithDelay(async () => {
@@ -15082,16 +14896,12 @@ class PassportImxProvider {
      */
     signers;
     signerInitialisationError;
-    constructor({ authManager, immutableXClient, confirmationScreen, config, passportEventEmitter, magicAdapter, imxApiClients, }) {
+    constructor({ authManager, immutableXClient, passportEventEmitter, magicAdapter, imxApiClients, guardianClient, }) {
         this.authManager = authManager;
         this.immutableXClient = immutableXClient;
-        this.guardianClient = new GuardianClient({
-            confirmationScreen,
-            config,
-            authManager,
-        });
         this.magicAdapter = magicAdapter;
         this.imxApiClients = imxApiClients;
+        this.guardianClient = guardianClient;
         this.initialiseSigners();
         passportEventEmitter.on(PassportEvents.LOGGED_OUT, this.handleLogout);
     }
@@ -15254,33 +15064,21 @@ class PassportImxProvider {
 
 class PassportImxProviderFactory {
     authManager;
-    config;
-    confirmationScreen;
     immutableXClient;
     magicAdapter;
     passportEventEmitter;
     imxApiClients;
-    constructor({ authManager, config, confirmationScreen, immutableXClient, magicAdapter, passportEventEmitter, imxApiClients, }) {
+    guardianClient;
+    constructor({ authManager, immutableXClient, magicAdapter, passportEventEmitter, imxApiClients, guardianClient, }) {
         this.authManager = authManager;
-        this.config = config;
-        this.confirmationScreen = confirmationScreen;
         this.immutableXClient = immutableXClient;
         this.magicAdapter = magicAdapter;
         this.passportEventEmitter = passportEventEmitter;
         this.imxApiClients = imxApiClients;
+        this.guardianClient = guardianClient;
     }
     async getProvider() {
-        let user = null;
-        try {
-            user = await this.authManager.getUser();
-        }
-        catch (e) {
-            // eslint-disable-next-line no-console
-            console.warn(e);
-        }
-        if (!user) {
-            user = await this.authManager.login();
-        }
+        const user = await this.authManager.getUserOrLogin();
         return this.createProviderInstance(user);
     }
     async getProviderSilent() {
@@ -15295,13 +15093,12 @@ class PassportImxProviderFactory {
             throw new PassportError('Failed to initialise', PassportErrorType.WALLET_CONNECTION_ERROR);
         }
         return new PassportImxProvider({
-            config: this.config,
             authManager: this.authManager,
             immutableXClient: this.immutableXClient,
-            confirmationScreen: this.confirmationScreen,
             passportEventEmitter: this.passportEventEmitter,
             magicAdapter: this.magicAdapter,
             imxApiClients: this.imxApiClients,
+            guardianClient: this.guardianClient,
         });
     }
 }
@@ -15796,6 +15593,38 @@ class RelayerClient {
     }
 }
 
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+var ProviderErrorCode;
+(function (ProviderErrorCode) {
+    ProviderErrorCode[ProviderErrorCode["USER_REJECTED_REQUEST"] = 4001] = "USER_REJECTED_REQUEST";
+    ProviderErrorCode[ProviderErrorCode["UNAUTHORIZED"] = 4100] = "UNAUTHORIZED";
+    ProviderErrorCode[ProviderErrorCode["UNSUPPORTED_METHOD"] = 4200] = "UNSUPPORTED_METHOD";
+    ProviderErrorCode[ProviderErrorCode["DISCONNECTED"] = 4900] = "DISCONNECTED";
+})(ProviderErrorCode || (ProviderErrorCode = {}));
+var RpcErrorCode;
+(function (RpcErrorCode) {
+    RpcErrorCode[RpcErrorCode["RPC_SERVER_ERROR"] = -32000] = "RPC_SERVER_ERROR";
+    RpcErrorCode[RpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    RpcErrorCode[RpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    RpcErrorCode[RpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    RpcErrorCode[RpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+    RpcErrorCode[RpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    RpcErrorCode[RpcErrorCode["TRANSACTION_REJECTED"] = -32003] = "TRANSACTION_REJECTED";
+})(RpcErrorCode || (RpcErrorCode = {}));
+class JsonRpcError extends Error {
+    message;
+    code;
+    constructor(code, message) {
+        super(message);
+        this.message = message;
+        this.code = code;
+    }
+}
+
 const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
 async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiClients, accessToken, jsonRpcProvider, }) {
     const web3Provider = new Web3Provider(magicProvider);
@@ -15830,17 +15659,7 @@ async function registerZkEvmUser({ authManager, magicProvider, multiRollupApiCli
 }
 
 const loginZkEvmUser = async ({ authManager, magicAdapter, multiRollupApiClients, jsonRpcProvider, }) => {
-    let user = null;
-    try {
-        user = await authManager.getUser();
-    }
-    catch (err) {
-        // eslint-disable-next-line no-console
-        console.warn('eth_requestAccounts` failed to retrieve a cached user session:', err);
-    }
-    if (!user) {
-        user = await authManager.login();
-    }
+    const user = await authManager.getUserOrLogin();
     if (!user.idToken) {
         throw new Error('User is missing idToken');
     }
@@ -15865,6 +15684,171 @@ const loginZkEvmUser = async ({ authManager, magicAdapter, multiRollupApiClients
     };
 };
 
+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();
+const transformGuardianTransactions = (txs) => {
+    try {
+        return txs.map((t) => ({
+            delegateCall: t.delegateCall === true,
+            revertOnError: t.revertOnError === true,
+            gasLimit: t.gasLimit ? convertBigNumberishToString(t.gasLimit) : '0',
+            target: t.to ?? ethers.constants.AddressZero,
+            value: t.value ? convertBigNumberishToString(t.value) : '0',
+            data: t.data ? t.data.toString() : '0x',
+        }));
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, `Transaction failed to parsing: ${errorMessage}`);
+    }
+};
+class GuardianClient {
+    transactionAPI;
+    messageAPI;
+    confirmationScreen;
+    crossSdkBridgeEnabled;
+    authManager;
+    constructor({ confirmationScreen, config, authManager }) {
+        const guardianConfiguration = new Configuration({ basePath: config.imxPublicApiDomain });
+        this.confirmationScreen = confirmationScreen;
+        this.crossSdkBridgeEnabled = config.crossSdkBridgeEnabled;
+        this.messageAPI = new MessagesApi(guardianConfiguration);
+        this.transactionAPI = new TransactionsApi(guardianConfiguration);
+        this.authManager = authManager;
+    }
+    /**
+     * Open confirmation screen and close it automatically if the
+     * underlying task fails.
+     */
+    withConfirmationScreen(popupWindowSize) {
+        return (task) => this.withConfirmationScreenTask(popupWindowSize)(task)();
+    }
+    withConfirmationScreenTask(popupWindowSize) {
+        return (task) => async () => {
+            this.confirmationScreen.loading(popupWindowSize);
+            try {
+                return await task();
+            }
+            catch (err) {
+                this.confirmationScreen.closeWindow();
+                throw err;
+            }
+        };
+    }
+    withDefaultConfirmationScreenTask(task) {
+        return this.withConfirmationScreenTask()(task);
+    }
+    async evaluateImxTransaction({ payloadHash }) {
+        const finallyFn = () => {
+            this.confirmationScreen.closeWindow();
+        };
+        const user = await this.authManager.getUser();
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
+        const transactionRes = await retryWithDelay(async () => this.transactionAPI.getTransactionByID({
+            transactionID: payloadHash,
+            chainType: 'starkex',
+        }, { headers }), { finallyFn });
+        if (!transactionRes.data.id) {
+            throw new Error("Transaction doesn't exists");
+        }
+        const evaluateImxRes = await this.transactionAPI.evaluateTransaction({
+            id: payloadHash,
+            transactionEvaluationRequest: {
+                chainType: 'starkex',
+            },
+        }, { headers });
+        const { confirmationRequired } = evaluateImxRes.data;
+        if (confirmationRequired) {
+            if (this.crossSdkBridgeEnabled) {
+                throw new Error(transactionRejectedCrossSdkBridgeError);
+            }
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(payloadHash, user.imx.ethAddress, TransactionApprovalRequestChainTypeEnum.Starkex);
+            if (!confirmationResult.confirmed) {
+                throw new Error('Transaction rejected by user');
+            }
+        }
+        else {
+            this.confirmationScreen.closeWindow();
+        }
+    }
+    async evaluateEVMTransaction({ chainId, nonce, metaTransactions, }) {
+        const user = await this.authManager.getUser();
+        const headers = { Authorization: `Bearer ${user.accessToken}` };
+        const guardianTransactions = transformGuardianTransactions(metaTransactions);
+        try {
+            const transactionEvaluationResponseAxiosResponse = await this.transactionAPI.evaluateTransaction({
+                id: 'evm',
+                transactionEvaluationRequest: {
+                    chainType: 'evm',
+                    chainId,
+                    transactionData: {
+                        nonce,
+                        userAddress: user.zkEvm.ethAddress,
+                        metaTransactions: guardianTransactions,
+                    },
+                },
+            }, { headers });
+            return transactionEvaluationResponseAxiosResponse.data;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Transaction failed to validate with error: ${errorMessage}`);
+        }
+    }
+    async validateEVMTransaction({ chainId, nonce, metaTransactions, }) {
+        const transactionEvaluationResponse = await this.evaluateEVMTransaction({
+            chainId,
+            nonce,
+            metaTransactions,
+        });
+        const { confirmationRequired, transactionId } = transactionEvaluationResponse;
+        if (confirmationRequired && this.crossSdkBridgeEnabled) {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
+        }
+        if (confirmationRequired && !!transactionId) {
+            const user = await this.authManager.getUser();
+            const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, user.zkEvm.ethAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
+            if (!confirmationResult.confirmed) {
+                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Transaction rejected by user');
+            }
+        }
+        else {
+            this.confirmationScreen.closeWindow();
+        }
+    }
+    async evaluateMessage({ chainID, payload }) {
+        try {
+            const user = await this.authManager.getUser();
+            if (user === null) {
+                throw new PassportError('evaluateMessage requires a valid ID token or refresh token. Please log in first', PassportErrorType.NOT_LOGGED_IN_ERROR);
+            }
+            const messageEvalResponse = await this.messageAPI.evaluateMessage({ messageEvaluationRequest: { chainID, payload } }, { headers: { Authorization: `Bearer ${user.accessToken}` } });
+            return messageEvalResponse.data;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Message failed to validate with error: ${errorMessage}`);
+        }
+    }
+    async validateMessage({ chainID, payload }) {
+        const { messageId, confirmationRequired } = await this.evaluateMessage({ chainID, payload });
+        if (confirmationRequired && this.crossSdkBridgeEnabled) {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
+        }
+        if (confirmationRequired && !!messageId) {
+            const user = await this.authManager.getUser();
+            const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress);
+            if (!confirmationResult.confirmed) {
+                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
+            }
+        }
+        else {
+            this.confirmationScreen.closeWindow();
+        }
+    }
+}
+
 const MAX_TRANSACTION_HASH_RETRIEVAL_RETRIES = 30;
 const TRANSACTION_HASH_RETRIEVAL_WAIT = 1000;
 const getMetaTransactions = async (metaTransaction, nonce, chainId, walletAddress, signer, relayerClient) => {
@@ -16009,7 +15993,6 @@ const signTypedDataV4 = async ({ params, method, magicProvider, jsonRpcProvider,
 class ZkEvmProvider {
     authManager;
     config;
-    confirmationScreen;
     magicAdapter;
     multiRollupApiClients;
     jsonRpcProvider; // Used for read
@@ -16019,11 +16002,11 @@ class ZkEvmProvider {
     magicProvider; // Used for signing
     zkevmAddress;
     isPassport = true;
-    constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, passportEventEmitter, }) {
+    constructor({ authManager, magicAdapter, config, multiRollupApiClients, passportEventEmitter, guardianClient, }) {
         this.authManager = authManager;
         this.magicAdapter = magicAdapter;
         this.config = config;
-        this.confirmationScreen = confirmationScreen;
+        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.
@@ -16043,7 +16026,6 @@ class ZkEvmProvider {
         const shouldEmitAccountsChanged = this.isLoggedIn();
         this.magicProvider = undefined;
         this.relayerClient = undefined;
-        this.guardianClient = undefined;
         if (shouldEmitAccountsChanged) {
             this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, []);
         }
@@ -16051,8 +16033,7 @@ class ZkEvmProvider {
     isLoggedIn() {
         return this.magicProvider !== undefined
             && this.zkevmAddress !== undefined
-            && this.relayerClient !== undefined
-            && this.guardianClient !== undefined;
+            && this.relayerClient !== undefined;
     }
     async performRequest(request) {
         switch (request.method) {
@@ -16062,7 +16043,6 @@ class ZkEvmProvider {
                 }
                 const { magicProvider, user } = await loginZkEvmUser({
                     authManager: this.authManager,
-                    config: this.config,
                     magicAdapter: this.magicAdapter,
                     multiRollupApiClients: this.multiRollupApiClients,
                     jsonRpcProvider: this.jsonRpcProvider,
@@ -16073,11 +16053,6 @@ class ZkEvmProvider {
                     jsonRpcProvider: this.jsonRpcProvider,
                     authManager: this.authManager,
                 });
-                this.guardianClient = new GuardianClient({
-                    confirmationScreen: this.confirmationScreen,
-                    config: this.config,
-                    authManager: this.authManager,
-                });
                 this.zkevmAddress = user.zkEvm.ethAddress;
                 this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [user.zkEvm.ethAddress]);
                 return [user.zkEvm.ethAddress];
@@ -16256,15 +16231,19 @@ const buildPrivateVars = (passportModuleConfiguration) => {
     const immutableXClient = passportModuleConfiguration.overrides
         ? passportModuleConfiguration.overrides.immutableXClient
         : new IMXClient({ baseConfig: passportModuleConfiguration.baseConfig });
+    const guardianClient = new GuardianClient({
+        confirmationScreen,
+        config,
+        authManager,
+    });
     const imxApiClients = buildImxApiClients(passportModuleConfiguration);
     const passportImxProviderFactory = new PassportImxProviderFactory({
         authManager,
-        config,
-        confirmationScreen,
         immutableXClient,
         magicAdapter,
         passportEventEmitter,
         imxApiClients,
+        guardianClient,
     });
     return {
         config,
@@ -16275,6 +16254,7 @@ const buildPrivateVars = (passportModuleConfiguration) => {
         multiRollupApiClients,
         passportEventEmitter,
         passportImxProviderFactory,
+        guardianClient,
     };
 };
 class Passport {
@@ -16286,6 +16266,7 @@ class Passport {
     multiRollupApiClients;
     passportImxProviderFactory;
     passportEventEmitter;
+    guardianClient;
     constructor(passportModuleConfiguration) {
         const privateVars = buildPrivateVars(passportModuleConfiguration);
         this.config = privateVars.config;
@@ -16296,6 +16277,7 @@ class Passport {
         this.multiRollupApiClients = privateVars.multiRollupApiClients;
         this.passportEventEmitter = privateVars.passportEventEmitter;
         this.passportImxProviderFactory = privateVars.passportImxProviderFactory;
+        this.guardianClient = privateVars.guardianClient;
         setPassportClientId(passportModuleConfiguration.clientId);
         track('passport', 'initialised');
     }
@@ -16315,8 +16297,8 @@ class Passport {
             authManager: this.authManager,
             magicAdapter: this.magicAdapter,
             config: this.config,
-            confirmationScreen: this.confirmationScreen,
             multiRollupApiClients: this.multiRollupApiClients,
+            guardianClient: this.guardianClient,
         });
     }
     /**