@imtbl/wallet 2.12.3 → 2.12.4-alpha.1

package/dist/types/zkEvm/sequenceCompat.d.ts

@@ -1,35 +1,65 @@
 export declare const walletContracts: {
     mainModule: {
-        abi: ({
-            type: string;
-            name: string;
-            constant: boolean;
-            inputs: {
-                type: string;
-            }[];
-            outputs: {
-                type: string;
-            }[];
-            payable: boolean;
-            stateMutability: string;
-        } | {
-            type: string;
-            name: string;
-            constant: boolean;
-            inputs: ({
-                components: {
-                    type: string;
-                    name: string;
-                }[];
-                type: string;
-            } | {
-                type: string;
-                components?: undefined;
-            })[];
-            outputs: never[];
-            payable: boolean;
-            stateMutability: string;
-        })[];
+        abi: readonly [{
+            readonly type: "function";
+            readonly name: "nonce";
+            readonly constant: true;
+            readonly inputs: readonly [];
+            readonly outputs: readonly [{
+                readonly type: "uint256";
+            }];
+            readonly payable: false;
+            readonly stateMutability: "view";
+        }, {
+            readonly type: "function";
+            readonly name: "readNonce";
+            readonly constant: true;
+            readonly inputs: readonly [{
+                readonly type: "uint256";
+                readonly name: "_space";
+            }];
+            readonly outputs: readonly [{
+                readonly type: "uint256";
+            }];
+            readonly payable: false;
+            readonly stateMutability: "view";
+        }, {
+            readonly type: "function";
+            readonly name: "execute";
+            readonly constant: false;
+            readonly inputs: readonly [{
+                readonly components: readonly [{
+                    readonly type: "bool";
+                    readonly name: "delegateCall";
+                }, {
+                    readonly type: "bool";
+                    readonly name: "revertOnError";
+                }, {
+                    readonly type: "uint256";
+                    readonly name: "gasLimit";
+                }, {
+                    readonly type: "address";
+                    readonly name: "target";
+                }, {
+                    readonly type: "uint256";
+                    readonly name: "value";
+                }, {
+                    readonly type: "bytes";
+                    readonly name: "data";
+                }];
+                readonly name: "_txs";
+                readonly type: "tuple[]";
+            }, {
+                readonly type: "uint256";
+                readonly name: "_nonce";
+            }, {
+                readonly type: "bytes";
+                readonly name: "_signature";
+            }];
+            readonly outputs: readonly [];
+            readonly payable: false;
+            readonly stateMutability: "nonpayable";
+        }];
     };
 };
 export type SequenceSigner = {

package/dist/types/zkEvm/signTypedDataV4.d.ts

@@ -1,14 +1,17 @@
 import { Flow } from '@imtbl/metrics';
-import { Signer, JsonRpcProvider } from 'ethers';
+import type { PublicClient } from 'viem';
 import GuardianClient from '../guardian';
+import { TypedDataPayload } from './types';
 import { RelayerClient } from './relayerClient';
+import type { WalletSigner } from '../types';
 export type SignTypedDataV4Params = {
-    ethSigner: Signer;
-    rpcProvider: JsonRpcProvider;
+    ethSigner: WalletSigner;
+    rpcProvider: PublicClient;
     relayerClient: RelayerClient;
     method: string;
     params: Array<any>;
     guardianClient: GuardianClient;
     flow: Flow;
 };
+export declare const transformTypedData: (typedData: string | object, chainId: bigint) => TypedDataPayload;
 export declare const signTypedDataV4: ({ params, method, ethSigner, rpcProvider, relayerClient, guardianClient, flow, }: SignTypedDataV4Params) => Promise<string>;

package/dist/types/zkEvm/transactionHelpers.d.ts

@@ -1,10 +1,21 @@
 import { Flow } from '@imtbl/metrics';
-import { Signer, TransactionRequest, JsonRpcProvider, BigNumberish } from 'ethers';
+import type { PublicClient, Hex } from 'viem';
 import { RelayerClient } from './relayerClient';
 import GuardianClient from '../guardian';
+import type { WalletSigner } from '../types';
+/**
+ * Transaction request type compatible with eth_sendTransaction
+ */
+export interface TransactionRequest {
+    to?: string;
+    data?: Hex | string | null;
+    value?: bigint;
+    nonce?: bigint;
+    chainId?: bigint | number;
+}
 export type TransactionParams = {
-    ethSigner: Signer;
-    rpcProvider: JsonRpcProvider;
+    ethSigner: WalletSigner;
+    rpcProvider: PublicClient;
     guardianClient: GuardianClient;
     relayerClient: RelayerClient;
     zkEvmAddress: string;
@@ -24,7 +35,7 @@ export declare const prepareAndSignTransaction: ({ transactionRequest, ethSigner
 }) => Promise<{
     signedTransactions: string;
     relayerId: string;
-    nonce: BigNumberish;
+    nonce: bigint;
 }>;
 export declare const prepareAndSignEjectionTransaction: ({ transactionRequest, ethSigner, zkEvmAddress, flow, }: EjectionTransactionParams & {
     transactionRequest: TransactionRequest;

package/dist/types/zkEvm/types.d.ts

@@ -1,4 +1,3 @@
-import { BigNumberish } from 'ethers';
 import { JsonRpcError } from './JsonRpcError';
 export declare enum RelayerTransactionStatus {
     PENDING = "PENDING",
@@ -24,19 +23,19 @@ export interface FeeOption {
 }
 export interface MetaTransaction {
     to: string;
-    value?: BigNumberish | null;
+    value?: bigint | null;
     data?: string | null;
-    nonce?: BigNumberish;
-    gasLimit?: BigNumberish;
+    nonce?: bigint;
+    gasLimit?: bigint;
     delegateCall?: boolean;
     revertOnError?: boolean;
 }
 export interface MetaTransactionNormalised {
     delegateCall: boolean;
     revertOnError: boolean;
-    gasLimit: BigNumberish;
+    gasLimit: bigint;
     target: string;
-    value: BigNumberish;
+    value: bigint;
     data: string;
 }
 export interface TypedDataPayload {

package/dist/types/zkEvm/user/registerZkEvmUser.d.ts

@@ -1,13 +1,14 @@
 import { MultiRollupApiClients } from '@imtbl/generated-clients';
 import { Flow } from '@imtbl/metrics';
-import { Signer, JsonRpcProvider } from 'ethers';
+import type { PublicClient } from 'viem';
 import { Auth } from '@imtbl/auth';
+import type { WalletSigner } from '../../types';
 export type RegisterZkEvmUserInput = {
     auth: Auth;
-    ethSigner: Signer;
+    ethSigner: WalletSigner;
     multiRollupApiClients: MultiRollupApiClients;
     accessToken: string;
-    rpcProvider: JsonRpcProvider;
+    rpcProvider: PublicClient;
     flow: Flow;
 };
 export declare function registerZkEvmUser({ auth, ethSigner, multiRollupApiClients, accessToken, rpcProvider, flow, }: RegisterZkEvmUserInput): Promise<string>;

package/dist/types/zkEvm/walletHelpers.d.ts

@@ -1,21 +1,22 @@
-import { BigNumberish, Signer, JsonRpcProvider } from 'ethers';
+import { type PublicClient, type Hex } from 'viem';
 import { MetaTransaction, MetaTransactionNormalised, TypedDataPayload } from './types';
+import type { WalletSigner } from '../types';
 export declare const getNormalisedTransactions: (txs: MetaTransaction[]) => MetaTransactionNormalised[];
-export declare const digestOfTransactionsAndNonce: (nonce: BigNumberish, normalisedTransactions: MetaTransactionNormalised[]) => string;
-export declare const encodedTransactions: (normalisedTransactions: MetaTransactionNormalised[]) => string;
+export declare const digestOfTransactionsAndNonce: (nonce: bigint, normalisedTransactions: MetaTransactionNormalised[]) => Hex;
+export declare const encodedTransactions: (normalisedTransactions: MetaTransactionNormalised[]) => Hex;
 /**
- * This helper function is used to coerce the type <BigNumber | undefined> to BigNumber for the
+ * This helper function is used to coerce the type <bigint | undefined> to bigint for the
  * getNonce function above.
- * @param {BigNumber} nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
- * @returns {BigNumber} The passed in nonceSpace or instead initialises the nonce to 0.
+ * @param nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
+ * @returns The passed in nonceSpace or instead initialises the nonce to 0.
  */
 export declare const coerceNonceSpace: (nonceSpace?: bigint) => bigint;
 /**
  * This helper function is used to encode the nonce into a 256 bit value where the space is encoded into
  * the first 160 bits, and the nonce the remaining 96 bits.
- * @param {BigNumber} nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
- * @param nonce {BigNumber} nonce - Sequential number starting at 0, and incrementing in single steps e.g. 0,1,2,...
- * @returns {BigNumber} The encoded value where the space is left shifted 96 bits, and the nonce is in the first 96 bits.
+ * @param nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
+ * @param nonce - Sequential number starting at 0, and incrementing in single steps e.g. 0,1,2,...
+ * @returns The encoded value where the space is left shifted 96 bits, and the nonce is in the first 96 bits.
  */
 export declare const encodeNonce: (nonceSpace: bigint, nonce: bigint) => bigint;
 /**
@@ -24,10 +25,10 @@ export declare const encodeNonce: (nonceSpace: bigint, nonce: bigint) => bigint;
  * wallet address do not. This function overload can be used to invoke transactions in parallel per smart
  * contract wallet if required.
  */
-export declare const getNonce: (rpcProvider: JsonRpcProvider, smartContractWalletAddress: string, nonceSpace?: bigint) => Promise<bigint>;
-export declare const encodeMessageSubDigest: (chainId: bigint, walletAddress: string, digest: string) => string;
-export declare const signMetaTransactions: (metaTransactions: MetaTransaction[], nonce: BigNumberish, chainId: bigint, walletAddress: string, signer: Signer) => Promise<string>;
+export declare const getNonce: (rpcProvider: PublicClient, smartContractWalletAddress: string, nonceSpace?: bigint) => Promise<bigint>;
+export declare const encodeMessageSubDigest: (chainId: bigint, walletAddress: string, digest: string) => Hex;
+export declare const signMetaTransactions: (metaTransactions: MetaTransaction[], nonce: bigint, chainId: bigint, walletAddress: string, signer: WalletSigner) => Promise<string>;
 export declare const packSignatures: (EOASignature: string, EOAAddress: string, relayerSignature: string) => string;
-export declare const signAndPackTypedData: (typedData: TypedDataPayload, relayerSignature: string, chainId: bigint, walletAddress: string, signer: Signer) => Promise<string>;
-export declare const signERC191Message: (chainId: bigint, payload: string, signer: Signer, walletAddress: string) => Promise<string>;
+export declare const signAndPackTypedData: (typedData: TypedDataPayload, relayerSignature: string, chainId: bigint, walletAddress: string, signer: WalletSigner) => Promise<string>;
+export declare const signERC191Message: (chainId: bigint, payload: string, signer: WalletSigner, walletAddress: string) => Promise<string>;
 export declare const getEip155ChainId: (chainId: number) => string;

package/dist/types/zkEvm/zkEvmProvider.d.ts

@@ -1,9 +1,8 @@
 import { MultiRollupApiClients } from '@imtbl/generated-clients';
-import { Signer } from 'ethers';
 import { Provider, RequestArguments } from './types';
 import { Auth, TypedEventEmitter } from '@imtbl/auth';
 import { WalletConfiguration } from '../config';
-import { PassportEventMap, User } from '../types';
+import { PassportEventMap, User, WalletSigner } from '../types';
 import GuardianClient from '../guardian';
 export type ZkEvmProviderInput = {
     auth: Auth;
@@ -11,7 +10,7 @@ export type ZkEvmProviderInput = {
     multiRollupApiClients: MultiRollupApiClients;
     passportEventEmitter: TypedEventEmitter<PassportEventMap>;
     guardianClient: GuardianClient;
-    ethSigner: Signer;
+    ethSigner: WalletSigner;
     user: User | null;
     sessionActivityApiUrl: string | null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imtbl/wallet",
-  "version": "2.12.3",
+  "version": "2.12.4-alpha.1",
   "description": "Wallet SDK for Immutable",
   "author": "Immutable",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
@@ -25,11 +25,10 @@
     }
   },
   "dependencies": {
-    "@imtbl/auth": "2.12.3",
-    "@imtbl/generated-clients": "2.12.3",
-    "@imtbl/metrics": "2.12.3",
-    "@imtbl/toolkit": "2.12.3",
-    "ethers": "^6.13.4"
+    "@imtbl/auth": "2.12.4-alpha.1",
+    "@imtbl/generated-clients": "2.12.4-alpha.1",
+    "@imtbl/metrics": "2.12.4-alpha.1",
+    "viem": "~2.18.0"
   },
   "devDependencies": {
     "@swc/core": "^1.3.36",

package/src/guardian/index.ts

@@ -1,5 +1,5 @@
 import * as GeneratedClients from '@imtbl/generated-clients';
-import { BigNumberish, ZeroAddress } from 'ethers';
+import { zeroAddress } from 'viem';
 import { Auth, IAuthConfiguration } from '@imtbl/auth';
 import ConfirmationScreen from '../confirmation/confirmation';
 import { JsonRpcError, ProviderErrorCode, RpcErrorCode } from '../zkEvm/JsonRpcError';
@@ -37,7 +37,7 @@ const transactionRejectedCrossSdkBridgeError = 'Transaction requires confirmatio
   + ' supported in this environment. Please contact Immutable support if you need to enable this feature.';
 
 export const convertBigNumberishToString = (
-  value: BigNumberish,
+  value: bigint,
 ): string => BigInt(value).toString();
 
 const transformGuardianTransactions = (
@@ -48,7 +48,7 @@ const transformGuardianTransactions = (
       delegateCall: t.delegateCall === true,
       revertOnError: t.revertOnError === true,
       gasLimit: t.gasLimit ? convertBigNumberishToString(t.gasLimit) : '0',
-      target: t.to ?? ZeroAddress,
+      target: t.to ?? zeroAddress,
       value: t.value ? convertBigNumberishToString(t.value) : '0',
       data: t.data ? t.data.toString() : '0x',
     }));

package/src/magic/magicTEESigner.ts

@@ -1,11 +1,10 @@
 /* eslint-disable no-bitwise */
-import { AbstractSigner, Signer } from 'ethers';
 import { MagicTeeApiClients } from '@imtbl/generated-clients';
 import { Flow, trackDuration } from '@imtbl/metrics';
 import { WalletError, WalletErrorType } from '../errors';
 import { Auth } from '@imtbl/auth';
 import { withMetricsAsync } from '../utils/metrics';
-import { isUserZkEvm, User } from '../types';
+import { isUserZkEvm, User, WalletSigner } from '../types';
 import { isAxiosError } from '../utils/http';
 
 const CHAIN_IDENTIFIER = 'ETH';
@@ -58,7 +57,11 @@ const toBase64 = (value: string): string => {
   return output;
 };
 
-export default class MagicTEESigner extends AbstractSigner {
+/**
+ * MagicTEESigner implements the WalletSigner interface for Magic TEE-based signing.
+ * This signer delegates cryptographic operations to the Magic TEE service.
+ */
+export default class MagicTEESigner implements WalletSigner {
   private readonly auth: Auth;
 
   private readonly magicTeeApiClient: MagicTeeApiClients;
@@ -68,7 +71,6 @@ export default class MagicTEESigner extends AbstractSigner {
   private createWalletPromise: Promise<UserWallet> | null = null;
 
   constructor(auth: Auth, magicTeeApiClient: MagicTeeApiClients) {
-    super();
     this.auth = auth;
     this.magicTeeApiClient = magicTeeApiClient;
   }
@@ -184,19 +186,19 @@ export default class MagicTEESigner extends AbstractSigner {
     };
   }
 
-  public async getAddress(): Promise<string> {
+  public async getAddress(): Promise<`0x${string}`> {
     const userWallet = await this.getUserWallet();
-    return userWallet.walletAddress;
+    return userWallet.walletAddress as `0x${string}`;
   }
 
-  public async signMessage(message: string | Uint8Array): Promise<string> {
+  public async signMessage(message: string | Uint8Array): Promise<`0x${string}`> {
     // Call getUserWallet to ensure that the createWallet endpoint has been called at least once,
     // as this is a prerequisite for signing messages.
     await this.getUserWallet();
 
     const messageToSign = message instanceof Uint8Array ? `0x${toHex(message)}` : message;
     const user = await this.getUserOrThrow();
-    const headers = await MagicTEESigner.getHeaders(user);
+    const headers = MagicTEESigner.getHeaders(user);
 
     return withMetricsAsync(async (flow: Flow) => {
       try {
@@ -217,7 +219,7 @@ export default class MagicTEESigner extends AbstractSigner {
           Math.round(performance.now() - startTime),
         );
 
-        return response.data.signature;
+        return response.data.signature as `0x${string}`;
       } catch (error) {
         let errorMessage: string = 'MagicTEE: Failed to sign message using EOA';
 
@@ -235,19 +237,4 @@ export default class MagicTEESigner extends AbstractSigner {
       }
     }, 'magicSignMessage');
   }
-
-  // eslint-disable-next-line class-methods-use-this
-  connect(): Signer {
-    throw new Error('Method not implemented.');
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  signTransaction(): Promise<string> {
-    throw new Error('Method not implemented.');
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  signTypedData(): Promise<string> {
-    throw new Error('Method not implemented.');
-  }
 }

package/src/types.ts

@@ -2,9 +2,19 @@ import { Flow } from '@imtbl/metrics';
 import {
   Auth, TypedEventEmitter, type AuthEventMap,
 } from '@imtbl/auth';
-import { BigNumberish } from 'ethers';
 import { JsonRpcError } from './zkEvm/JsonRpcError';
 
+/**
+ * A viem-compatible signer interface for wallet operations.
+ * This replaces ethers' AbstractSigner/Signer.
+ */
+export interface WalletSigner {
+  /** Get the wallet address */
+  getAddress(): Promise<`0x${string}`>;
+  /** Sign a message (EIP-191 personal_sign) */
+  signMessage(message: string | Uint8Array): Promise<`0x${string}`>;
+}
+
 // Re-export auth types for convenience
 export type {
   User, UserProfile, UserZkEvm, DirectLoginMethod, AuthEventMap,
@@ -83,10 +93,10 @@ export interface TypedDataPayload {
 
 export interface MetaTransaction {
   to: string;
-  value?: BigNumberish | null;
+  value?: bigint | null;
   data?: string | null;
-  nonce?: BigNumberish;
-  gasLimit?: BigNumberish;
+  nonce?: bigint;
+  gasLimit?: bigint;
   delegateCall?: boolean;
   revertOnError?: boolean;
 }
@@ -94,9 +104,9 @@ export interface MetaTransaction {
 export interface MetaTransactionNormalised {
   delegateCall: boolean;
   revertOnError: boolean;
-  gasLimit: BigNumberish;
+  gasLimit: bigint;
   target: string;
-  value: BigNumberish;
+  value: bigint;
   data: string;
 }
 

package/src/utils/crypto.ts

@@ -0,0 +1,85 @@
+import type { WalletSigner } from '../types';
+
+/**
+ * Signature components for Ethereum signatures
+ */
+type SignatureOptions = {
+  r: bigint;
+  s: bigint;
+  recoveryParam: number | null | undefined;
+};
+
+/**
+ * Adds '0x' prefix to a hex string if not present
+ */
+function addHexPrefix(hex: string): string {
+  return hex.startsWith('0x') ? hex : `0x${hex}`;
+}
+
+/**
+ * Removes '0x' prefix from a hex string if present
+ */
+function removeHexPrefix(hex: string): string {
+  return hex.startsWith('0x') ? hex.slice(2) : hex;
+}
+
+/**
+ * Pads a hex string to a specified length with leading zeros
+ */
+function padLeft(str: string, length: number): string {
+  return str.padStart(length, '0');
+}
+
+/**
+ * Serializes Ethereum signature components into a hex string.
+ * This format is used for IMX registration with golang backend.
+ * @see https://github.com/ethers-io/ethers.js/issues/823
+ */
+function serializeEthSignature(sig: SignatureOptions): string {
+  const rHex = padLeft(sig.r.toString(16), 64);
+  const sHex = padLeft(sig.s.toString(16), 64);
+  const vHex = padLeft(sig.recoveryParam?.toString(16) || '', 2);
+  return addHexPrefix(rHex + sHex + vHex);
+}
+
+/**
+ * Imports recovery parameter from hex string, normalizing v value
+ */
+function importRecoveryParam(v: string): number | undefined {
+  if (!v.trim()) return undefined;
+
+  const vValue = parseInt(v, 16);
+  // If v >= 27, subtract 27 to get recovery param (0 or 1)
+  return vValue >= 27 ? vValue - 27 : vValue;
+}
+
+/**
+ * Deserializes a signature hex string into its components (r, s, v)
+ */
+function deserializeSignature(sig: string, size = 64): SignatureOptions {
+  const cleanSig = removeHexPrefix(sig);
+  return {
+    r: BigInt(`0x${cleanSig.substring(0, size)}`),
+    s: BigInt(`0x${cleanSig.substring(size, size * 2)}`),
+    recoveryParam: importRecoveryParam(cleanSig.substring(size * 2, size * 2 + 2)),
+  };
+}
+
+/**
+ * Signs a message with the provided signer and returns a serialized signature
+ * suitable for IMX registration and authorization.
+ *
+ * This is inlined from @imtbl/toolkit to avoid ethers dependency.
+ *
+ * @param payload - The message to sign
+ * @param signer - A WalletSigner implementation
+ * @returns The serialized signature as a hex string
+ */
+export async function signRaw(
+  payload: string,
+  signer: WalletSigner,
+): Promise<string> {
+  const rawSignature = await signer.signMessage(payload);
+  const signature = deserializeSignature(rawSignature);
+  return serializeEthSignature(signature);
+}

package/src/utils/string.ts

@@ -1,10 +1,38 @@
-import { getBytes, stripZerosLeft, toUtf8String } from 'ethers';
+import { toBytes, type Hex } from 'viem';
+
+/**
+ * Strip leading zero bytes from a Uint8Array
+ */
+const stripZerosLeft = (bytes: Uint8Array): Uint8Array => {
+  let start = 0;
+  while (start < bytes.length && bytes[start] === 0) {
+    start++;
+  }
+  return bytes.slice(start);
+};
+
+/**
+ * Convert UTF-8 bytes to string
+ */
+const toUtf8String = (bytes: Uint8Array): string => {
+  if (typeof TextDecoder !== 'undefined') {
+    return new TextDecoder('utf-8').decode(bytes);
+  }
+
+  // Fallback for environments without TextDecoder
+  let result = '';
+  for (let i = 0; i < bytes.length; i++) {
+    result += String.fromCharCode(bytes[i]);
+  }
+  return decodeURIComponent(escape(result));
+};
 
 export const hexToString = (hex: string) => {
   if (!hex) return hex;
 
   try {
-    const stripped = stripZerosLeft(getBytes(hex));
+    const bytes = toBytes(hex as Hex);
+    const stripped = stripZerosLeft(bytes);
     return toUtf8String(stripped);
   } catch (e) {
     return hex;

package/src/zkEvm/personalSign.ts

@@ -1,14 +1,15 @@
 import { Flow } from '@imtbl/metrics';
-import { Signer, JsonRpcProvider } from 'ethers';
+import type { PublicClient } from 'viem';
 import { JsonRpcError, RpcErrorCode } from './JsonRpcError';
 import { hexToString } from '../utils/string';
 import GuardianClient from '../guardian';
 import { RelayerClient } from './relayerClient';
 import { packSignatures, signERC191Message } from './walletHelpers';
+import type { WalletSigner } from '../types';
 
 interface PersonalSignParams {
-  ethSigner: Signer;
-  rpcProvider: JsonRpcProvider;
+  ethSigner: WalletSigner;
+  rpcProvider: PublicClient;
   params: any[];
   zkEvmAddress: string;
   guardianClient: GuardianClient;
@@ -38,7 +39,7 @@ export const personalSign = async ({
 
   // Convert message into a string if it's a hex
   const payload = hexToString(message);
-  const { chainId } = await rpcProvider.getNetwork();
+  const chainId = await rpcProvider.getChainId();
   flow.addEvent('endDetectNetwork');
   const chainIdBigNumber = BigInt(chainId);
 
@@ -46,7 +47,7 @@ export const personalSign = async ({
   const eoaSignaturePromise = signERC191Message(chainIdBigNumber, payload, ethSigner, fromAddress);
   eoaSignaturePromise.then(() => flow.addEvent('endEOASignature'));
 
-  await guardianClient.evaluateERC191Message({ chainID: chainId, payload });
+  await guardianClient.evaluateERC191Message({ chainID: chainIdBigNumber, payload });
   flow.addEvent('endEvaluateERC191Message');
 
   const [eoaSignature, relayerSignature] = await Promise.all([