@imtbl/sdk 1.41.3 → 1.42.0

package/dist/passport.js

@@ -11460,7 +11460,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.41.3' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.42.0' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -11639,7 +11639,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.41.3';
+const SDK_VERSION = '1.42.0';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';
@@ -12029,7 +12029,7 @@ const addKeysToHeadersOverride = (baseConfig, overrides) => {
 /* eslint-disable @typescript-eslint/naming-convention */
 class ApiConfiguration extends index$2.Configuration {
 }
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.41.3' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.42.0' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -12070,7 +12070,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     coreContractAddress,
     registrationContractAddress,
     registrationV4ContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.41.3',
+    sdkVersion: 'ts-immutable-sdk-1.42.0',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({
@@ -18970,9 +18970,7 @@ var globalAxios = axios;
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-// Some imports not used depending on template conditions
-// @ts-ignore
-const BASE_PATH = "https://guardian.sandbox.imtbl.com".replace(/\/+$/, "");
+const BASE_PATH = "https://api.immutable.com".replace(/\/+$/, "");
 /**
  *
  * @export
@@ -18987,7 +18985,7 @@ class BaseAPI {
         this.axios = axios;
         if (configuration) {
             this.configuration = configuration;
-            this.basePath = configuration.basePath || this.basePath;
+            this.basePath = configuration.basePath ?? basePath;
         }
     }
 }
@@ -18999,12 +18997,17 @@ class BaseAPI {
  */
 class RequiredError extends Error {
     field;
-    name = "RequiredError";
     constructor(field, msg) {
         super(msg);
         this.field = field;
+        this.name = "RequiredError";
     }
 }
+/**
+ *
+ * @export
+ */
+const operationServerMap = {};
 
 /* tslint:disable */
 /* eslint-disable */
@@ -19047,6 +19050,8 @@ const setBearerAuthToObject = async function (object, configuration) {
     }
 };
 function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
+    if (parameter == null)
+        return;
     if (typeof parameter === "object") {
         if (Array.isArray(parameter)) {
             parameter.forEach(item => setFlattenedQueryParams(urlSearchParams, item, key));
@@ -19099,7 +19104,7 @@ const toPathString = function (url) {
  */
 const createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, configuration) {
     return (axios = globalAxios, basePath = BASE_PATH) => {
-        const axiosRequestArgs = { ...axiosArgs.options, url: (configuration?.basePath || basePath) + axiosArgs.url };
+        const axiosRequestArgs = { ...axiosArgs.options, url: (axios.defaults.baseURL ? '' : configuration?.basePath ?? basePath) + axiosArgs.url };
         return axios.request(axiosRequestArgs);
     };
 };
@@ -19123,6 +19128,38 @@ const createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, confi
  */
 const MessagesApiAxiosParamCreator = function (configuration) {
     return {
+        /**
+         * Approve a pending erc191 message
+         * @summary Approve a pending erc191 message
+         * @param {string} messageID id for the message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        approvePendingERC191Message: async (messageID, options = {}) => {
+            // verify required parameter 'messageID' is not null or undefined
+            assertParamExists('approvePendingERC191Message', 'messageID', messageID);
+            const localVarPath = `/guardian/v1/erc191-messages/{messageID}/approve`
+                .replace(`{${"messageID"}}`, encodeURIComponent(String(messageID)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Approve a pending evm message
          * @summary Approve a pending evm message
@@ -19155,6 +19192,39 @@ const MessagesApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Check if a given erc191 message is valid
+         * @summary Evaluate an erc191 message to sign
+         * @param {ERC191MessageEvaluationRequest} eRC191MessageEvaluationRequest Specifies the kind of transaction
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        evaluateErc191Message: async (eRC191MessageEvaluationRequest, options = {}) => {
+            // verify required parameter 'eRC191MessageEvaluationRequest' is not null or undefined
+            assertParamExists('evaluateErc191Message', 'eRC191MessageEvaluationRequest', eRC191MessageEvaluationRequest);
+            const localVarPath = `/guardian/v1/erc191-messages/evaluate`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(eRC191MessageEvaluationRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Check if a given message is valid  for EVM
          * @summary Evaluate an evm message to sign
@@ -19188,6 +19258,38 @@ const MessagesApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Get an erc191 message by id
+         * @summary Info for a specific erc191 message
+         * @param {string} messageID The id of the erc191 message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getErc191MessageByID: async (messageID, options = {}) => {
+            // verify required parameter 'messageID' is not null or undefined
+            assertParamExists('getErc191MessageByID', 'messageID', messageID);
+            const localVarPath = `/guardian/v1/erc191-messages/{messageID}`
+                .replace(`{${"messageID"}}`, encodeURIComponent(String(messageID)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication BearerAuth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Get an evm message by id
          * @summary Info for a specific evm message
@@ -19229,6 +19331,19 @@ const MessagesApiAxiosParamCreator = function (configuration) {
 const MessagesApiFp = function (configuration) {
     const localVarAxiosParamCreator = MessagesApiAxiosParamCreator(configuration);
     return {
+        /**
+         * Approve a pending erc191 message
+         * @summary Approve a pending erc191 message
+         * @param {string} messageID id for the message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async approvePendingERC191Message(messageID, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.approvePendingERC191Message(messageID, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MessagesApi.approvePendingERC191Message']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Approve a pending evm message
          * @summary Approve a pending evm message
@@ -19238,7 +19353,22 @@ const MessagesApiFp = function (configuration) {
          */
         async approvePendingMessage(messageID, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.approvePendingMessage(messageID, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MessagesApi.approvePendingMessage']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Check if a given erc191 message is valid
+         * @summary Evaluate an erc191 message to sign
+         * @param {ERC191MessageEvaluationRequest} eRC191MessageEvaluationRequest Specifies the kind of transaction
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async evaluateErc191Message(eRC191MessageEvaluationRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.evaluateErc191Message(eRC191MessageEvaluationRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MessagesApi.evaluateErc191Message']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
          * Check if a given message is valid  for EVM
@@ -19249,7 +19379,22 @@ const MessagesApiFp = function (configuration) {
          */
         async evaluateMessage(messageEvaluationRequest, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.evaluateMessage(messageEvaluationRequest, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MessagesApi.evaluateMessage']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get an erc191 message by id
+         * @summary Info for a specific erc191 message
+         * @param {string} messageID The id of the erc191 message
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getErc191MessageByID(messageID, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getErc191MessageByID(messageID, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MessagesApi.getErc191MessageByID']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
          * Get an evm message by id
@@ -19260,7 +19405,9 @@ const MessagesApiFp = function (configuration) {
          */
         async getMessageByID(messageID, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.getMessageByID(messageID, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['MessagesApi.getMessageByID']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
@@ -19271,6 +19418,17 @@ const MessagesApiFp = function (configuration) {
  * @extends {BaseAPI}
  */
 class MessagesApi extends BaseAPI {
+    /**
+     * Approve a pending erc191 message
+     * @summary Approve a pending erc191 message
+     * @param {MessagesApiApprovePendingERC191MessageRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MessagesApi
+     */
+    approvePendingERC191Message(requestParameters, options) {
+        return MessagesApiFp(this.configuration).approvePendingERC191Message(requestParameters.messageID, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Approve a pending evm message
      * @summary Approve a pending evm message
@@ -19282,6 +19440,17 @@ class MessagesApi extends BaseAPI {
     approvePendingMessage(requestParameters, options) {
         return MessagesApiFp(this.configuration).approvePendingMessage(requestParameters.messageID, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Check if a given erc191 message is valid
+     * @summary Evaluate an erc191 message to sign
+     * @param {MessagesApiEvaluateErc191MessageRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MessagesApi
+     */
+    evaluateErc191Message(requestParameters, options) {
+        return MessagesApiFp(this.configuration).evaluateErc191Message(requestParameters.eRC191MessageEvaluationRequest, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Check if a given message is valid  for EVM
      * @summary Evaluate an evm message to sign
@@ -19293,6 +19462,17 @@ class MessagesApi extends BaseAPI {
     evaluateMessage(requestParameters, options) {
         return MessagesApiFp(this.configuration).evaluateMessage(requestParameters.messageEvaluationRequest, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Get an erc191 message by id
+     * @summary Info for a specific erc191 message
+     * @param {MessagesApiGetErc191MessageByIDRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof MessagesApi
+     */
+    getErc191MessageByID(requestParameters, options) {
+        return MessagesApiFp(this.configuration).getErc191MessageByID(requestParameters.messageID, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Get an evm message by id
      * @summary Info for a specific evm message
@@ -19403,7 +19583,7 @@ const TransactionsApiAxiosParamCreator = function (configuration) {
          * Get a transaction by payload hash
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
-         * @param {'starkex' | 'evm'} chainType roll up type
+         * @param {GetTransactionByIDChainTypeEnum} chainType roll up type
          * @param {string} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -19460,7 +19640,9 @@ const TransactionsApiFp = function (configuration) {
          */
         async approvePendingTransaction(payloadHash, transactionApprovalRequest, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.approvePendingTransaction(payloadHash, transactionApprovalRequest, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TransactionsApi.approvePendingTransaction']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
          * Check if the transaction is valid by transaction ID for both StarkEx and EVM
@@ -19472,20 +19654,24 @@ const TransactionsApiFp = function (configuration) {
          */
         async evaluateTransaction(id, transactionEvaluationRequest, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.evaluateTransaction(id, transactionEvaluationRequest, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TransactionsApi.evaluateTransaction']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
          * Get a transaction by payload hash
          * @summary Info for a specific transaction
          * @param {string} transactionID The id of the starkex transaction to retrieve
-         * @param {'starkex' | 'evm'} chainType roll up type
+         * @param {GetTransactionByIDChainTypeEnum} chainType roll up type
          * @param {string} [chainID] ID of evm chain
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
         async getTransactionByID(transactionID, chainType, chainID, options) {
             const localVarAxiosArgs = await localVarAxiosParamCreator.getTransactionByID(transactionID, chainType, chainID, options);
-            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['TransactionsApi.getTransactionByID']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     };
 };
@@ -19579,6 +19765,13 @@ class Configuration {
      * @memberof Configuration
      */
     basePath;
+    /**
+     * override server index
+     *
+     * @type {number}
+     * @memberof Configuration
+     */
+    serverIndex;
     /**
      * base options for axios calls
      *
@@ -19600,6 +19793,7 @@ class Configuration {
         this.password = param.password;
         this.accessToken = param.accessToken;
         this.basePath = param.basePath;
+        this.serverIndex = param.serverIndex;
         this.baseOptions = param.baseOptions;
         this.formDataCtor = param.formDataCtor;
     }
@@ -21468,7 +21662,7 @@ class ConfirmationScreen {
             this.showConfirmationScreen(href, messageHandler, resolve);
         });
     }
-    requestMessageConfirmation(messageID, etherAddress) {
+    requestMessageConfirmation(messageID, etherAddress, messageType) {
         return new Promise((resolve, reject) => {
             const messageHandler = ({ data, origin }) => {
                 if (origin !== this.config.passportDomain
@@ -21504,7 +21698,11 @@ class ConfirmationScreen {
                 }
             };
             window.addEventListener('message', messageHandler);
-            const href = this.getHref('zkevm/message', { messageID, etherAddress });
+            const href = this.getHref('zkevm/message', {
+                messageID,
+                etherAddress,
+                ...(messageType ? { messageType } : {}),
+            });
             this.showConfirmationScreen(href, messageHandler, resolve);
         });
     }
@@ -21619,7 +21817,7 @@ class TypedEventEmitter {
 
 const SIGNATURE_WEIGHT = 1; // Weight of a single signature in the multi-sig
 const TRANSACTION_SIGNATURE_THRESHOLD = 1; // Total required weight in the multi-sig for a transaction
-const EIP712_SIGNATURE_THRESHOLD = 2; // Total required weight in the multi-sig for data signing
+const PACKED_SIGNATURE_THRESHOLD = 2; // Total required weight in the multi-sig for data signing
 const ETH_SIGN_FLAG = '02';
 const ETH_SIGN_PREFIX = '\x19\x01';
 const META_TRANSACTIONS_TYPE = `tuple(
@@ -21664,7 +21862,7 @@ const getNonce = async (rpcProvider, smartContractWalletAddress) => {
     throw new Error('Unexpected result from contract.nonce() call.');
 };
 const encodeMessageSubDigest = (chainId, walletAddress, digest) => (utils$2.solidityPack(['string', 'uint256', 'address', 'bytes32'], [ETH_SIGN_PREFIX, chainId, walletAddress, digest]));
-const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walletAddress, signer) => {
+const signMetaTransactions = async (metaTransactions, nonce, chainId, walletAddress, signer) => {
     const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
     // Get the hash
     const digest = digestOfTransactionsAndNonce(nonce, normalisedMetaTransactions);
@@ -21697,29 +21895,14 @@ const getSignedMetaTransactions = async (metaTransactions, nonce, chainId, walle
         encodedSignature,
     ]);
 };
-const decodeRelayerTypedDataSignature = (relayerSignature) => {
+const decodeRelayerSignature = (relayerSignature) => {
     const signatureWithThreshold = `0x0000${relayerSignature}`;
     return v1.signature.decodeSignature(signatureWithThreshold);
 };
-const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAddress, signer) => {
-    // Ethers auto-generates the EIP712Domain type in the TypedDataEncoder, and so it needs to be removed
-    const types = { ...typedData.types };
-    // @ts-ignore
-    delete types.EIP712Domain;
-    // Hash the EIP712 payload and generate the complete payload
-    const { _TypedDataEncoder: typedDataEncoder } = utils$2;
-    const typedDataHash = typedDataEncoder.hash(typedData.domain, types, typedData.message);
-    const messageSubDigest = encodeMessageSubDigest(chainId, walletAddress, typedDataHash);
-    const hash = utils$2.keccak256(messageSubDigest);
-    // Sign the sub digest
-    // https://github.com/immutable/wallet-contracts/blob/7824b5f24b2e0eb2dc465ecb5cd71f3984556b73/src/contracts/modules/commons/ModuleAuth.sol#L155
-    const hashArray = utils$2.arrayify(hash);
-    const startTime = performance.now();
-    const ethsigNoType = await signer.signMessage(hashArray);
-    trackDuration('passport', 'magicSignMessageTypedData', Math.round(performance.now() - startTime));
-    const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
+const packSignatures = (EOASignature, EOAAddress, relayerSignature) => {
+    const signedDigest = `${EOASignature}${ETH_SIGN_FLAG}`;
     // Combine the relayer and user signatures; sort by address to match the imageHash order
-    const { signers: relayerSigners } = decodeRelayerTypedDataSignature(relayerSignature);
+    const { signers: relayerSigners } = decodeRelayerSignature(relayerSignature);
     const combinedSigners = [
         ...relayerSigners,
         {
@@ -21727,7 +21910,7 @@ const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAd
             unrecovered: true,
             weight: SIGNATURE_WEIGHT,
             signature: signedDigest,
-            address: await signer.getAddress(),
+            address: EOAAddress,
         },
     ];
     const sortedSigners = combinedSigners.sort((a, b) => {
@@ -21743,10 +21926,38 @@ const getSignedTypedData = async (typedData, relayerSignature, chainId, walletAd
     });
     return v1.signature.encodeSignature({
         version: 1,
-        threshold: EIP712_SIGNATURE_THRESHOLD,
+        threshold: PACKED_SIGNATURE_THRESHOLD,
         signers: sortedSigners,
     });
 };
+const signAndPackTypedData = async (typedData, relayerSignature, chainId, walletAddress, signer) => {
+    // Ethers auto-generates the EIP712Domain type in the TypedDataEncoder, and so it needs to be removed
+    const types = { ...typedData.types };
+    // @ts-ignore
+    delete types.EIP712Domain;
+    // Hash the EIP712 payload and generate the complete payload
+    const { _TypedDataEncoder: typedDataEncoder } = utils$2;
+    const typedDataHash = typedDataEncoder.hash(typedData.domain, types, typedData.message);
+    const messageSubDigest = encodeMessageSubDigest(chainId, walletAddress, typedDataHash);
+    const hash = utils$2.keccak256(messageSubDigest);
+    // Sign the sub digest
+    // https://github.com/immutable/wallet-contracts/blob/7824b5f24b2e0eb2dc465ecb5cd71f3984556b73/src/contracts/modules/commons/ModuleAuth.sol#L155
+    const hashArray = utils$2.arrayify(hash);
+    const startTime = performance.now();
+    const eoaSignature = await signer.signMessage(hashArray);
+    trackDuration('passport', 'magicSignMessageTypedData', Math.round(performance.now() - startTime));
+    const eoaAddress = await signer.getAddress();
+    return packSignatures(eoaSignature, eoaAddress, relayerSignature);
+};
+const signERC191Message = async (chainId, payload, signer, walletAddress) => {
+    // Generate digest
+    const digest = utils$2.keccak256(utils$2.toUtf8Bytes(payload));
+    // Generate subDigest
+    const subDigest = encodeMessageSubDigest(chainId, walletAddress, digest);
+    const subDigestHash = utils$2.keccak256(subDigest);
+    const subDigestHashArray = utils$2.arrayify(subDigestHash);
+    return signer.signMessage(subDigestHashArray);
+};
 const getEip155ChainId = (chainId) => `eip155:${chainId}`;
 
 class RelayerClient {
@@ -21828,6 +22039,19 @@ class RelayerClient {
         const { result } = await this.postToRelayer(payload);
         return result;
     }
+    async imSign(address, message) {
+        const { chainId } = await this.rpcProvider.detectNetwork();
+        const payload = {
+            method: 'im_sign',
+            params: [{
+                    address,
+                    message,
+                    chainId: getEip155ChainId(chainId),
+                }],
+        };
+        const { result } = await this.postToRelayer(payload);
+        return result;
+    }
 }
 
 /**
@@ -21996,7 +22220,7 @@ class GuardianClient {
         const headers = { Authorization: `Bearer ${user.accessToken}` };
         const guardianTransactions = transformGuardianTransactions(metaTransactions);
         try {
-            const transactionEvaluationResponseAxiosResponse = await this.transactionAPI.evaluateTransaction({
+            const response = await this.transactionAPI.evaluateTransaction({
                 id: 'evm',
                 transactionEvaluationRequest: {
                     chainType: 'evm',
@@ -22008,7 +22232,7 @@ class GuardianClient {
                     },
                 },
             }, { headers });
-            return transactionEvaluationResponseAxiosResponse.data;
+            return response.data;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -22036,11 +22260,11 @@ class GuardianClient {
             this.confirmationScreen.closeWindow();
         }
     }
-    async evaluateMessage({ chainID, payload }) {
+    async handleEIP712MessageEvaluation({ chainID, payload }) {
         try {
             const user = await this.authManager.getUserZkEvm();
             if (user === null) {
-                throw new PassportError('evaluateMessage requires a valid ID token or refresh token. Please log in first', PassportErrorType.NOT_LOGGED_IN_ERROR);
+                throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'User not logged in. Please log in first.');
             }
             const messageEvalResponse = await this.messageAPI.evaluateMessage({ messageEvaluationRequest: { chainID, payload } }, { headers: { Authorization: `Bearer ${user.accessToken}` } });
             return messageEvalResponse.data;
@@ -22050,14 +22274,49 @@ class GuardianClient {
             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 });
+    async evaluateEIP712Message({ chainID, payload }) {
+        const { messageId, confirmationRequired } = await this.handleEIP712MessageEvaluation({ chainID, payload });
+        if (confirmationRequired && this.crossSdkBridgeEnabled) {
+            throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
+        }
+        if (confirmationRequired && !!messageId) {
+            const user = await this.authManager.getUserZkEvm();
+            const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress, 'eip712');
+            if (!confirmationResult.confirmed) {
+                throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
+            }
+        }
+        else {
+            this.confirmationScreen.closeWindow();
+        }
+    }
+    async handleERC191MessageEvaluation({ chainID, payload }) {
+        try {
+            const user = await this.authManager.getUserZkEvm();
+            if (user === null) {
+                throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'User not logged in. Please log in first.');
+            }
+            const messageEvalResponse = await this.messageAPI.evaluateErc191Message({
+                eRC191MessageEvaluationRequest: {
+                    chainID: getEip155ChainId(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 evaluateERC191Message({ chainID, payload }) {
+        const { messageId, confirmationRequired } = await this.handleERC191MessageEvaluation({ chainID, payload });
         if (confirmationRequired && this.crossSdkBridgeEnabled) {
             throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
         }
         if (confirmationRequired && !!messageId) {
             const user = await this.authManager.getUserZkEvm();
-            const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress);
+            const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress, 'erc191');
             if (!confirmationResult.confirmed) {
                 throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
             }
@@ -22138,7 +22397,7 @@ const sendTransaction = async ({ params, ethSigner, rpcProvider, relayerClient,
     validateEVMTransactionPromise.then(() => flow.addEvent('endValidateEVMTransaction'));
     // NOTE: We sign again because we now are adding the fee transaction, so the
     // whole payload is different and needs a new signature.
-    const getSignedMetaTransactionsPromise = getSignedMetaTransactions(metaTransactions, nonce, chainIdBigNumber, zkevmAddress, ethSigner);
+    const getSignedMetaTransactionsPromise = signMetaTransactions(metaTransactions, nonce, chainIdBigNumber, zkevmAddress, ethSigner);
     getSignedMetaTransactionsPromise.then(() => flow.addEvent('endGetSignedMetaTransactions'));
     const [, signedTransactions] = await Promise.all([
         validateEVMTransactionPromise,
@@ -22223,15 +22482,57 @@ const signTypedDataV4 = async ({ params, method, ethSigner, rpcProvider, relayer
     const { chainId } = await rpcProvider.detectNetwork();
     const typedData = transformTypedData(typedDataParam, chainId);
     flow.addEvent('endDetectNetwork');
-    await guardianClient.validateMessage({ chainID: String(chainId), payload: typedData });
+    await guardianClient.evaluateEIP712Message({ chainID: String(chainId), payload: typedData });
     flow.addEvent('endValidateMessage');
     const relayerSignature = await relayerClient.imSignTypedData(fromAddress, typedData);
     flow.addEvent('endRelayerSignTypedData');
-    const signature = await getSignedTypedData(typedData, relayerSignature, BigNumber.from(chainId), fromAddress, ethSigner);
+    const signature = await signAndPackTypedData(typedData, relayerSignature, BigNumber.from(chainId), fromAddress, ethSigner);
     flow.addEvent('getSignedTypedData');
     return signature;
 };
 
+const hexToString = (hex) => {
+    if (!hex)
+        return hex;
+    try {
+        const stripped = utils$2.stripZeros(utils$2.arrayify(hex));
+        const buff = Buffer.from(stripped);
+        return buff.length === 32 ? hex : utils$2.toUtf8String(stripped);
+    }
+    catch (e) {
+        return hex;
+    }
+};
+
+const personalSign = async ({ params, ethSigner, zkEvmAddress, rpcProvider, guardianClient, relayerClient, flow, }) => {
+    const message = params[0];
+    const fromAddress = params[1];
+    if (!fromAddress || !message) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'personal_sign requires an address and a message');
+    }
+    if (fromAddress.toLowerCase() !== zkEvmAddress.toLowerCase()) {
+        throw new JsonRpcError(RpcErrorCode.INVALID_PARAMS, 'personal_sign requires the signer to be the from address');
+    }
+    // Convert message into a string if it's a hex
+    const payload = hexToString(message);
+    const { chainId } = await rpcProvider.detectNetwork();
+    flow.addEvent('endDetectNetwork');
+    const chainIdBigNumber = BigNumber.from(chainId);
+    // Sign the message with the EOA without blocking
+    const eoaSignaturePromise = signERC191Message(chainIdBigNumber, payload, ethSigner, fromAddress);
+    eoaSignaturePromise.then(() => flow.addEvent('endEOASignature'));
+    await guardianClient.evaluateERC191Message({ chainID: chainId, payload });
+    flow.addEvent('endEvaluateERC191Message');
+    const [eoaSignature, relayerSignature] = await Promise.all([
+        eoaSignaturePromise,
+        relayerClient.imSign(fromAddress, payload),
+    ]);
+    flow.addEvent('endRelayerSign');
+    const eoaAddress = await ethSigner.getAddress();
+    flow.addEvent('endGetEOAAddress');
+    return packSignatures(eoaSignature, eoaAddress, relayerSignature);
+};
+
 const isZkEvmUser = (user) => 'zkEvm' in user;
 class ZkEvmProvider {
     #authManager;
@@ -22407,6 +22708,38 @@ class ZkEvmProvider {
             case 'eth_accounts': {
                 return this.#zkEvmAddress ? [this.#zkEvmAddress] : [];
             }
+            case 'personal_sign': {
+                if (!this.#zkEvmAddress) {
+                    throw new JsonRpcError(ProviderErrorCode.UNAUTHORIZED, 'Unauthorised - call eth_requestAccounts first');
+                }
+                const flow = trackFlow('passport', 'personalSign');
+                try {
+                    return await this.#guardianClient.withConfirmationScreen({ width: 480, height: 720 })(async () => {
+                        const ethSigner = await this.#getSigner();
+                        flow.addEvent('endGetSigner');
+                        return await personalSign({
+                            params: request.params || [],
+                            ethSigner,
+                            zkEvmAddress: this.#zkEvmAddress,
+                            rpcProvider: this.#rpcProvider,
+                            guardianClient: this.#guardianClient,
+                            relayerClient: this.#relayerClient,
+                            flow,
+                        });
+                    });
+                }
+                catch (error) {
+                    let errorMessage = 'Unknown error';
+                    if (error instanceof Error) {
+                        errorMessage = error.message;
+                    }
+                    flow.addEvent('error', { errorMessage });
+                    throw error;
+                }
+                finally {
+                    flow.end();
+                }
+            }
             case 'eth_signTypedData':
             case 'eth_signTypedData_v4': {
                 if (!this.#zkEvmAddress) {