@imtbl/wallet 2.12.2 → 2.12.3-alpha.0

package/src/zkEvm/walletHelpers.ts

@@ -1,15 +1,24 @@
 import {
-  BigNumberish, Contract, getBytes, hashMessage,
-  Interface, keccak256, Signer, solidityPacked, ZeroAddress,
-  TypedDataEncoder, JsonRpcProvider, AbiCoder,
-  isError,
-} from 'ethers';
+  keccak256,
+  encodePacked,
+  encodeAbiParameters,
+  parseAbiParameters,
+  getContract,
+  encodeFunctionData,
+  toBytes,
+  hashMessage,
+  hashTypedData,
+  zeroAddress,
+  type PublicClient,
+  type Hex,
+} from 'viem';
 import { MetaTransaction, MetaTransactionNormalised, TypedDataPayload } from './types';
 import {
   decodeSequenceSignatureV1,
   encodeSequenceSignatureV1,
   walletContracts,
 } from './sequenceCompat';
+import type { WalletSigner } from '../types';
 
 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
@@ -17,56 +26,74 @@ const PACKED_SIGNATURE_THRESHOLD = 2; // Total required weight in the multi-sig
 
 const ETH_SIGN_FLAG = '02';
 const ETH_SIGN_PREFIX = '\x19\x01';
-const META_TRANSACTIONS_TYPE = `tuple(
-  bool delegateCall,
-  bool revertOnError,
-  uint256 gasLimit,
-  address target,
-  uint256 value,
-  bytes data
-)[]`;
+
+// ABI parameter type for meta transactions array
+const META_TRANSACTIONS_ABI_TYPE = parseAbiParameters(
+  '(bool delegateCall, bool revertOnError, uint256 gasLimit, address target, uint256 value, bytes data)[]',
+);
 
 export const getNormalisedTransactions = (txs: MetaTransaction[]): MetaTransactionNormalised[] => txs.map((t) => ({
   delegateCall: t.delegateCall === true,
   revertOnError: t.revertOnError === true,
   gasLimit: t.gasLimit ?? BigInt(0),
-  target: t.to ?? ZeroAddress,
+  target: (t.to ?? zeroAddress) as `0x${string}`,
   value: t.value ?? BigInt(0),
-  data: t.data ?? '0x',
+  data: (t.data ?? '0x') as `0x${string}`,
 }));
 
 export const digestOfTransactionsAndNonce = (
-  nonce: BigNumberish,
+  nonce: bigint,
   normalisedTransactions: MetaTransactionNormalised[],
-): string => {
-  const packMetaTransactionsNonceData = AbiCoder.defaultAbiCoder().encode(
-    ['uint256', META_TRANSACTIONS_TYPE],
-    [nonce, normalisedTransactions],
+): Hex => {
+  // Convert normalised transactions to the format expected by encodeAbiParameters
+  const txsForEncoding = normalisedTransactions.map((t) => ({
+    delegateCall: t.delegateCall,
+    revertOnError: t.revertOnError,
+    gasLimit: t.gasLimit,
+    target: t.target as `0x${string}`,
+    value: t.value,
+    data: t.data as `0x${string}`,
+  }));
+
+  const packMetaTransactionsNonceData = encodeAbiParameters(
+    [{ type: 'uint256' }, ...META_TRANSACTIONS_ABI_TYPE],
+    [nonce, txsForEncoding],
   );
   return keccak256(packMetaTransactionsNonceData);
 };
 
 export const encodedTransactions = (
   normalisedTransactions: MetaTransactionNormalised[],
-): string => AbiCoder.defaultAbiCoder().encode(
-  [META_TRANSACTIONS_TYPE],
-  [normalisedTransactions],
-);
+): Hex => {
+  const txsForEncoding = normalisedTransactions.map((t) => ({
+    delegateCall: t.delegateCall,
+    revertOnError: t.revertOnError,
+    gasLimit: t.gasLimit,
+    target: t.target as `0x${string}`,
+    value: t.value,
+    data: t.data as `0x${string}`,
+  }));
+
+  return encodeAbiParameters(
+    META_TRANSACTIONS_ABI_TYPE,
+    [txsForEncoding],
+  );
+};
 
 /**
- * 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 const coerceNonceSpace = (nonceSpace?: bigint): bigint => nonceSpace || 0n;
 
 /**
  * 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 const encodeNonce = (nonceSpace: bigint, nonce: bigint): bigint => {
   const shiftedSpace = BigInt(nonceSpace) * (2n ** 96n);
@@ -80,25 +107,31 @@ export const encodeNonce = (nonceSpace: bigint, nonce: bigint): bigint => {
  * contract wallet if required.
  */
 export const getNonce = async (
-  rpcProvider: JsonRpcProvider,
+  rpcProvider: PublicClient,
   smartContractWalletAddress: string,
   nonceSpace?: bigint,
 ): Promise<bigint> => {
   try {
-    const contract = new Contract(
-      smartContractWalletAddress,
-      walletContracts.mainModule.abi,
-      rpcProvider,
-    );
+    const contract = getContract({
+      address: smartContractWalletAddress as `0x${string}`,
+      abi: walletContracts.mainModule.abi,
+      client: rpcProvider,
+    });
     const space: bigint = coerceNonceSpace(nonceSpace); // Default nonce space is 0
-    const result = await contract.readNonce(space);
+    const result = await contract.read.readNonce([space]);
     if (typeof result === 'bigint') {
       return encodeNonce(space, result);
     }
-    throw new Error('Unexpected result from contract.nonce() call.');
+    throw new Error('Unexpected result from contract.readNonce() call.');
   } catch (error) {
-    if (isError(error, 'BAD_DATA')) {
-      // The most likely reason for a BAD_DATA error is that the smart contract wallet
+    // Check if the error is due to contract not being deployed (similar to ethers BAD_DATA)
+    // In viem, this typically manifests as a ContractFunctionExecutionError with empty return data
+    if (error instanceof Error && (
+      error.message.includes('returned no data')
+      || error.message.includes('execution reverted')
+      || error.message.includes('ContractFunctionExecutionError')
+    )) {
+      // The most likely reason for this error is that the smart contract wallet
       // has not been deployed yet, so we should default to a nonce of 0.
       return BigInt(0);
     }
@@ -107,19 +140,19 @@ export const getNonce = async (
   }
 };
 
-export const encodeMessageSubDigest = (chainId: bigint, walletAddress: string, digest: string): string => (
-  solidityPacked(
+export const encodeMessageSubDigest = (chainId: bigint, walletAddress: string, digest: string): Hex => (
+  encodePacked(
     ['string', 'uint256', 'address', 'bytes32'],
-    [ETH_SIGN_PREFIX, chainId, walletAddress, digest],
+    [ETH_SIGN_PREFIX, chainId, walletAddress as `0x${string}`, digest as `0x${string}`],
   )
 );
 
 export const signMetaTransactions = async (
   metaTransactions: MetaTransaction[],
-  nonce: BigNumberish,
+  nonce: bigint,
   chainId: bigint,
   walletAddress: string,
-  signer: Signer,
+  signer: WalletSigner,
 ): Promise<string> => {
   const normalisedMetaTransactions = getNormalisedTransactions(metaTransactions);
 
@@ -130,7 +163,7 @@ export const signMetaTransactions = async (
   const hash = keccak256(completePayload);
 
   // Sign the digest
-  const hashArray = getBytes(hash);
+  const hashArray = toBytes(hash);
   const ethsigNoType = await signer.signMessage(hashArray);
   const signedDigest = `${ethsigNoType}${ETH_SIGN_FLAG}`;
 
@@ -148,13 +181,22 @@ export const signMetaTransactions = async (
     ],
   });
 
-  // Encode the transaction;
-  const walletInterface = new Interface(walletContracts.mainModule.abi);
-  return walletInterface.encodeFunctionData(walletInterface.getFunction('execute') ?? '', [
-    normalisedMetaTransactions,
-    nonce,
-    encodedSignature,
-  ]);
+  // Encode the transaction using viem's encodeFunctionData
+  // Convert normalised transactions to tuple format for encoding
+  const txsForEncoding = normalisedMetaTransactions.map((t) => ({
+    delegateCall: t.delegateCall,
+    revertOnError: t.revertOnError,
+    gasLimit: t.gasLimit,
+    target: t.target as `0x${string}`,
+    value: t.value,
+    data: t.data as `0x${string}`,
+  }));
+
+  return encodeFunctionData({
+    abi: walletContracts.mainModule.abi,
+    functionName: 'execute',
+    args: [txsForEncoding, nonce, encodedSignature as `0x${string}`],
+  });
 };
 
 const decodeRelayerSignature = (relayerSignature: string) => {
@@ -205,21 +247,28 @@ export const signAndPackTypedData = async (
   relayerSignature: string,
   chainId: bigint,
   walletAddress: string,
-  signer: Signer,
+  signer: WalletSigner,
 ): Promise<string> => {
-  // Ethers auto-generates the EIP712Domain type in the TypedDataEncoder, and so it needs to be removed
+  // viem's hashTypedData handles EIP712Domain automatically
   const types = { ...typedData.types };
-  // @ts-ignore
-  delete types.EIP712Domain;
+  // Remove EIP712Domain from types as viem handles it
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { EIP712Domain, ...typesWithoutDomain } = types;
+
+  // Hash the EIP712 payload
+  const typedDataHash = hashTypedData({
+    domain: typedData.domain as Parameters<typeof hashTypedData>[0]['domain'],
+    types: typesWithoutDomain,
+    primaryType: typedData.primaryType,
+    message: typedData.message,
+  });
 
-  // Hash the EIP712 payload and generate the complete payload
-  const typedDataHash = TypedDataEncoder.hash(typedData.domain, types, typedData.message);
   const messageSubDigest = encodeMessageSubDigest(chainId, walletAddress, typedDataHash);
   const hash = keccak256(messageSubDigest);
 
   // Sign the sub digest
   // https://github.com/immutable/wallet-contracts/blob/7824b5f24b2e0eb2dc465ecb5cd71f3984556b73/src/contracts/modules/commons/ModuleAuth.sol#L155
-  const hashArray = getBytes(hash);
+  const hashArray = toBytes(hash);
   const eoaSignature = await signer.signMessage(hashArray);
   const eoaAddress = await signer.getAddress();
 
@@ -229,16 +278,16 @@ export const signAndPackTypedData = async (
 export const signERC191Message = async (
   chainId: bigint,
   payload: string,
-  signer: Signer,
+  signer: WalletSigner,
   walletAddress: string,
 ): Promise<string> => {
-  // Generate digest
+  // Generate digest using viem's hashMessage
   const digest = hashMessage(payload);
 
   // Generate subDigest
   const subDigest = encodeMessageSubDigest(chainId, walletAddress, digest);
   const subDigestHash = keccak256(subDigest);
-  const subDigestHashArray = getBytes(subDigestHash);
+  const subDigestHashArray = toBytes(subDigestHash);
 
   return signer.signMessage(subDigestHashArray);
 };

package/src/zkEvm/zkEvmProvider.ts

@@ -3,8 +3,11 @@ import {
   Flow, identify, trackError, trackFlow,
 } from '@imtbl/metrics';
 import {
-  JsonRpcProvider, Signer, toBeHex,
-} from 'ethers';
+  createPublicClient,
+  http,
+  toHex,
+  type PublicClient,
+} from 'viem';
 import {
   Provider,
   ProviderEvent,
@@ -14,7 +17,7 @@ import {
 import { Auth, TypedEventEmitter } from '@imtbl/auth';
 import { WalletConfiguration } from '../config';
 import {
-  PassportEventMap, AuthEvents, WalletEvents, User, UserZkEvm,
+  PassportEventMap, AuthEvents, WalletEvents, User, UserZkEvm, WalletSigner,
 } from '../types';
 import { RelayerClient } from './relayerClient';
 import { JsonRpcError, ProviderErrorCode, RpcErrorCode } from './JsonRpcError';
@@ -34,7 +37,7 @@ export type ZkEvmProviderInput = {
   multiRollupApiClients: MultiRollupApiClients;
   passportEventEmitter: TypedEventEmitter<PassportEventMap>;
   guardianClient: GuardianClient;
-  ethSigner: Signer;
+  ethSigner: WalletSigner;
   user: User | null;
   sessionActivityApiUrl: string | null;
 };
@@ -60,13 +63,13 @@ export class ZkEvmProvider implements Provider {
 
   readonly #guardianClient: GuardianClient;
 
-  readonly #rpcProvider: JsonRpcProvider; // Used for read
+  readonly #rpcProvider: PublicClient; // Used for read
 
   readonly #multiRollupApiClients: MultiRollupApiClients;
 
   readonly #relayerClient: RelayerClient;
 
-  readonly #ethSigner: Signer;
+  readonly #ethSigner: WalletSigner;
 
   public readonly isPassport: boolean = true;
 
@@ -87,9 +90,9 @@ export class ZkEvmProvider implements Provider {
     this.#sessionActivityApiUrl = sessionActivityApiUrl;
     this.#ethSigner = ethSigner;
 
-    // Create JsonRpcProvider for reading from the chain
-    this.#rpcProvider = new JsonRpcProvider(this.#config.zkEvmRpcUrl, undefined, {
-      staticNetwork: true,
+    // Create PublicClient for reading from the chain using viem
+    this.#rpcProvider = createPublicClient({
+      transport: http(this.#config.zkEvmRpcUrl),
     });
 
     // Create RelayerClient for transaction submission
@@ -347,40 +350,34 @@ export class ZkEvmProvider implements Provider {
         }
       }
       case 'eth_chainId': {
-        // Call detect network to fetch the chainId so to take advantage of
-        // the caching layer provided by StaticJsonRpcProvider.
-        // In case Passport is changed from StaticJsonRpcProvider to a
-        // JsonRpcProvider, this function will still work as expected given
-        // that detectNetwork call _uncachedDetectNetwork which will force
-        // the provider to re-fetch the chainId from remote.
-        const { chainId } = await this.#rpcProvider.getNetwork();
-        return toBeHex(chainId);
+        // Get chain ID using viem's PublicClient
+        const chainId = await this.#rpcProvider.getChainId();
+        return toHex(chainId);
       }
-      // Pass through methods
+      // Pass through methods - use viem's request method for raw RPC calls
       case 'eth_getBalance':
       case 'eth_getCode':
       case 'eth_getTransactionCount': {
         const [address, blockNumber] = request.params || [];
-        return this.#rpcProvider.send(request.method, [
-          address,
-          blockNumber || 'latest',
-        ]);
+        return this.#rpcProvider.request({
+          method: request.method as any,
+          params: [address, blockNumber || 'latest'],
+        });
       }
       case 'eth_getStorageAt': {
         const [address, storageSlot, blockNumber] = request.params || [];
-        return this.#rpcProvider.send(request.method, [
-          address,
-          storageSlot,
-          blockNumber || 'latest',
-        ]);
+        return this.#rpcProvider.request({
+          method: 'eth_getStorageAt',
+          params: [address, storageSlot, blockNumber || 'latest'],
+        });
       }
       case 'eth_call':
       case 'eth_estimateGas': {
         const [transaction, blockNumber] = request.params || [];
-        return this.#rpcProvider.send(request.method, [
-          transaction,
-          blockNumber || 'latest',
-        ]);
+        return this.#rpcProvider.request({
+          method: request.method as any,
+          params: [transaction, blockNumber || 'latest'],
+        });
       }
       case 'eth_gasPrice':
       case 'eth_blockNumber':
@@ -388,7 +385,10 @@ export class ZkEvmProvider implements Provider {
       case 'eth_getBlockByNumber':
       case 'eth_getTransactionByHash':
       case 'eth_getTransactionReceipt': {
-        return this.#rpcProvider.send(request.method, request.params || []);
+        return this.#rpcProvider.request({
+          method: request.method as any,
+          params: (request.params || []) as any,
+        });
       }
       case 'im_signEjectionTransaction': {
         const zkEvmAddress = await this.#getZkEvmAddress();