@walletmesh/aztec-rpc-wallet 0.1.0

package/src/serializers/transaction.ts

@@ -0,0 +1,342 @@
+import type { AztecWalletMethodMap } from '../types.js';
+import type { JSONRPCSerializedData, JSONRPCSerializer } from './types.js';
+import { encodeBase64, decodeBase64 } from './types.js';
+import { txHashSerializer } from './core.js';
+import { TxEffect, TxSimulationResult, inBlockSchemaFor, type TxProvingResult } from '@aztec/circuit-types';
+import { TxExecutionRequest, TxReceipt, Tx, AztecAddress } from '@aztec/aztec.js';
+
+import { SerializablePrivateExecutionResult, SerializableTxProvingResult } from './transaction-utils.js';
+
+/**
+ * Serializer for the aztec_createTxExecutionRequest RPC method.
+ * Handles serialization of transaction execution requests between JSON-RPC format and native Aztec types.
+ */
+export class AztecCreateTxExecutionRequestSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'],
+      AztecWalletMethodMap['aztec_createTxExecutionRequest']['result']
+    >
+{
+  params = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'],
+    ): JSONRPCSerializedData => {
+      const { exec } = value;
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(exec)),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_createTxExecutionRequest']['params'] => {
+      const exec = JSON.parse(decodeBase64(data.serialized));
+      return { exec };
+    },
+  };
+
+  result = {
+    serialize: (method: string, value: TxExecutionRequest): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(value.toString()),
+      };
+    },
+    deserialize: (method: string, data: JSONRPCSerializedData): TxExecutionRequest => {
+      return TxExecutionRequest.fromString(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_proveTx RPC method.
+ * Handles serialization of transaction proving requests and results between JSON-RPC format and native Aztec types.
+ * Includes handling of private execution results and proving outcomes.
+ */
+export class AztecProveTxSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_proveTx']['params'],
+      AztecWalletMethodMap['aztec_proveTx']['result']
+    >
+{
+  params = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_proveTx']['params'],
+    ): JSONRPCSerializedData => {
+      const { txRequest, privateExecutionResult } = value;
+      const serializablePrivateExecutionResult =
+        SerializablePrivateExecutionResult.from(privateExecutionResult);
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify([txRequest.toString(), serializablePrivateExecutionResult])),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_proveTx']['params'] => {
+      const [txRequest, privateExecutionResult] = JSON.parse(decodeBase64(data.serialized));
+      return {
+        txRequest: TxExecutionRequest.fromString(txRequest),
+        privateExecutionResult: SerializablePrivateExecutionResult.fromJSON(privateExecutionResult),
+      };
+    },
+  };
+
+  result = {
+    serialize: (method: string, value: TxProvingResult): JSONRPCSerializedData => {
+      const serializableTxProvingResult = SerializableTxProvingResult.from(value);
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(serializableTxProvingResult)),
+      };
+    },
+    deserialize: (method: string, data: JSONRPCSerializedData): TxProvingResult => {
+      return SerializableTxProvingResult.fromJSON(JSON.parse(decodeBase64(data.serialized)));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_sendTx RPC method.
+ * Handles serialization of transaction sending requests and transaction hash results between JSON-RPC format and native Aztec types.
+ */
+export class AztecSendTxSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_sendTx']['params'],
+      AztecWalletMethodMap['aztec_sendTx']['result']
+    >
+{
+  params = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_sendTx']['params'],
+    ): JSONRPCSerializedData => {
+      const { tx } = value;
+      return {
+        method,
+        serialized: encodeBase64(tx.toBuffer().toString('hex')),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_sendTx']['params'] => {
+      const tx = Tx.fromBuffer(Buffer.from(decodeBase64(data.serialized), 'hex'));
+      return { tx };
+    },
+  };
+
+  result = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_sendTx']['result'],
+    ): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(txHashSerializer.serialize(value)),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_sendTx']['result'] => {
+      return txHashSerializer.deserialize(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_getTxEffect RPC method.
+ * Handles serialization of transaction effect queries and results between JSON-RPC format and native Aztec types.
+ * Transaction effects represent the outcome and state changes caused by a transaction.
+ */
+export class AztecGetTxEffectSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getTxEffect']['params'],
+      AztecWalletMethodMap['aztec_getTxEffect']['result']
+    >
+{
+  params = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getTxEffect']['params'],
+    ): JSONRPCSerializedData => {
+      const { txHash } = value;
+      return {
+        method,
+        serialized: encodeBase64(txHashSerializer.serialize(txHash)),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getTxEffect']['params'] => {
+      const txHash = txHashSerializer.deserialize(decodeBase64(data.serialized));
+      return { txHash };
+    },
+  };
+
+  result = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getTxEffect']['result'],
+    ): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(TxEffect.schema.parse(value))),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getTxEffect']['result'] => {
+      return inBlockSchemaFor(TxEffect.schema).parse(JSON.parse(decodeBase64(data.serialized)));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_getTxReceipt RPC method.
+ * Handles serialization of transaction receipt queries and results between JSON-RPC format and native Aztec types.
+ * Transaction receipts contain detailed information about executed transactions.
+ */
+export class AztecGetTxReceiptSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getTxReceipt']['params'],
+      AztecWalletMethodMap['aztec_getTxReceipt']['result']
+    >
+{
+  params = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getTxReceipt']['params'],
+    ): JSONRPCSerializedData => {
+      const { txHash } = value;
+      return {
+        method,
+        serialized: encodeBase64(txHashSerializer.serialize(txHash)),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getTxReceipt']['params'] => {
+      const txHash = txHashSerializer.deserialize(decodeBase64(data.serialized));
+      return { txHash };
+    },
+  };
+
+  result = {
+    serialize: (method: string, value: TxReceipt): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(TxReceipt.schema.parse(value))),
+      };
+    },
+    deserialize: (method: string, data: JSONRPCSerializedData): TxReceipt => {
+      return TxReceipt.schema.parse(JSON.parse(decodeBase64(data.serialized)));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_simulateTx RPC method.
+ * Handles serialization of transaction simulation requests and results between JSON-RPC format and native Aztec types.
+ * Supports simulation configuration including public simulation, custom sender, validation options, and profiling.
+ */
+export class AztecSimulateTxSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_simulateTx']['params'],
+      AztecWalletMethodMap['aztec_simulateTx']['result']
+    >
+{
+  params = {
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_simulateTx']['params'],
+    ): JSONRPCSerializedData => {
+      const { txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile } = value;
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify([
+            txRequest.toString(),
+            simulatePublic,
+            msgSender,
+            skipTxValidation,
+            enforceFeePayment,
+            profile,
+          ]),
+        ),
+      };
+    },
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_simulateTx']['params'] => {
+      const [txRequest, simulatePublic, msgSender, skipTxValidation, enforceFeePayment, profile] = JSON.parse(
+        decodeBase64(data.serialized),
+      );
+      return {
+        txRequest: TxExecutionRequest.fromString(txRequest),
+        simulatePublic,
+        msgSender: msgSender ? AztecAddress.fromString(msgSender) : undefined,
+        skipTxValidation,
+        enforceFeePayment,
+        profile,
+      };
+    },
+  };
+
+  result = {
+    serialize: (method: string, value: TxSimulationResult): JSONRPCSerializedData => {
+      const serializablePrivateExecutionResult = SerializablePrivateExecutionResult.from(
+        value.privateExecutionResult,
+      );
+
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify({
+            privateExecutionResult: serializablePrivateExecutionResult,
+            publicInputs: value.publicInputs,
+            publicOutput: value.publicOutput,
+            profileResult: value.profileResult,
+          }),
+        ),
+      };
+    },
+    deserialize: (method: string, data: JSONRPCSerializedData): TxSimulationResult => {
+      const { privateExecutionResult, publicInputs, publicOutput, profileResult } = JSON.parse(
+        decodeBase64(data.serialized),
+      );
+      return new TxSimulationResult(
+        SerializablePrivateExecutionResult.fromJSON(privateExecutionResult),
+        publicInputs,
+        publicOutput,
+        profileResult,
+      );
+    },
+  };
+}
+
+/**
+ * Pre-instantiated serializer instances for each Aztec transaction-related RPC method.
+ * These instances can be used directly by the RPC handler implementation.
+ */
+export const aztecCreateTxExecutionRequestSerializer = new AztecCreateTxExecutionRequestSerializer();
+export const aztecProveTxSerializer = new AztecProveTxSerializer();
+export const aztecSendTxSerializer = new AztecSendTxSerializer();
+export const aztecGetTxEffectSerializer = new AztecGetTxEffectSerializer();
+export const aztecGetTxReceiptSerializer = new AztecGetTxReceiptSerializer();
+export const aztecSimulateTxSerializer = new AztecSimulateTxSerializer();

package/src/serializers/types.ts

@@ -0,0 +1,58 @@
+import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
+
+/**
+ * Base interface for type-specific serializers in the Aztec RPC wallet.
+ * Provides a standardized way to convert Aztec-specific types to and from string representations
+ * for network transmission. Each Aztec type (Fr, AztecAddress, etc.) implements this interface
+ * to ensure consistent serialization across the RPC layer.
+ *
+ * @typeParam T - The Aztec type being serialized (e.g., Fr, AztecAddress, TxHash)
+ */
+export interface TypeSerializer<T> {
+  /**
+   * Converts a value to its string representation for network transmission.
+   * Implementations should ensure the serialized form can be correctly deserialized
+   * back to the original type.
+   *
+   * @param value - The Aztec type value to serialize
+   * @returns A string representation suitable for network transmission
+   */
+  serialize(value: T): string;
+
+  /**
+   * Reconstructs a value from its string representation.
+   * Implementations should validate the input string and throw appropriate errors
+   * if the data cannot be correctly deserialized.
+   *
+   * @param data - The string data to deserialize, previously created by serialize()
+   * @returns The reconstructed Aztec type value
+   * @throws If the data is invalid or cannot be deserialized
+   */
+  deserialize(data: string): T;
+}
+
+// Re-export core JSON-RPC types from @walletmesh/jsonrpc
+export type { JSONRPCSerializedData, JSONRPCSerializer };
+
+/**
+ * Helper function to encode data as base64 for safe network transmission.
+ * Used throughout the serializers to ensure consistent encoding of binary data.
+ *
+ * @param data - The string data to encode
+ * @returns Base64 encoded string
+ */
+export function encodeBase64(data: string): string {
+  return btoa(data);
+}
+
+/**
+ * Helper function to decode base64 data back to its original form.
+ * Used throughout the serializers to decode data received over the network.
+ *
+ * @param data - The base64 encoded string to decode
+ * @returns Original decoded string
+ * @throws If the input is not valid base64
+ */
+export function decodeBase64(data: string): string {
+  return atob(data);
+}

package/src/types.ts

@@ -0,0 +1,295 @@
+import type {
+  AuthWitness,
+  AztecAddress,
+  ContractArtifact,
+  ContractClassWithId,
+  ContractInstanceWithAddress,
+  ExtendedNote,
+  Fr,
+  PXE,
+  TxExecutionRequest,
+  TxHash,
+  TxReceipt,
+  L2Block,
+  LogFilter,
+  Point,
+  SiblingPath,
+  PartialAddress,
+  CompleteAddress,
+  NodeInfo,
+  AccountWallet,
+  Tx,
+} from '@aztec/aztec.js';
+import type { IntentAction, IntentInnerHash } from '@aztec/aztec.js/utils';
+import type { ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import type { AbiDecoded } from '@aztec/foundation/abi';
+import type {
+  InBlock,
+  IncomingNotesFilter,
+  EventMetadataDefinition,
+  PrivateExecutionResult,
+  TxEffect,
+  TxProvingResult,
+  UniqueNote,
+  GetUnencryptedLogsResponse,
+  PXEInfo,
+  TxSimulationResult,
+} from '@aztec/circuit-types';
+import type { GasFees, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
+import type { JSONRPCEventMap, JSONRPCMiddleware } from '@walletmesh/jsonrpc';
+import type { JSONRPCWalletClient, WalletMethodMap } from '@walletmesh/router';
+import type { ContractArtifactCache } from './contractArtifactCache.js';
+
+/**
+ * Represents a single function call to a contract.
+ * @public
+ */
+export type TransactionFunctionCall = {
+  /** The address of the contract to interact with */
+  contractAddress: string;
+  /** The name of the function to call */
+  functionName: string;
+  /** The arguments to pass to the function */
+  args: unknown[];
+};
+
+/**
+ * Parameters for sending transactions.
+ * @public
+ */
+export type TransactionParams = {
+  /** Array of function calls to execute */
+  functionCalls: TransactionFunctionCall[];
+  /** Optional array of authorization witnesses for the transaction */
+  authwits?: string[];
+};
+
+export const BASE_WALLET_METHODS: (keyof AztecWalletBaseMethodMap)[] = [
+  'wm_getSupportedMethods',
+  'aztec_connect',
+  'aztec_getAccount',
+  'aztec_sendTransaction',
+  'aztec_simulateTransaction',
+] as const;
+
+/**
+ * A mapping of JSON-RPC methods to their parameters and return types for Aztec Wallets.
+ *
+ * This extends the base WalletMethodMap with Aztec-specific methods.
+ * @public
+ */
+export interface AztecWalletBaseMethodMap extends WalletMethodMap {
+  /**
+   * Connects to the Aztec network.
+   * @returns A boolean indicating if the connection was successful
+   */
+  aztec_connect: { result: boolean };
+
+  /**
+   * Gets the account address from the wallet.
+   * @returns The account address as a string
+   */
+  aztec_getAccount: { result: string };
+
+  /**
+   * Sends transactions to the Aztec network.
+   * @param params - The transactions to execute and optional authorization witnesses
+   * @returns The transaction hash as a string
+   */
+  aztec_sendTransaction: {
+    params: TransactionParams;
+    result: string;
+  };
+
+  /**
+   * Simulates a transaction without executing it.
+   * @param params - The transaction to simulate
+   * @returns The simulation result
+   */
+  aztec_simulateTransaction: {
+    params: TransactionFunctionCall;
+    result: unknown;
+  };
+
+  /**
+   * Returns the list of supported methods for the wallet.
+   * @returns An array of supported methods
+   */
+  wm_getSupportedMethods: {
+    result: string[];
+  };
+}
+
+export interface AztecWalletEventMap extends JSONRPCEventMap {
+  // TODO: What events do we need?
+}
+
+/**
+ * Holds the context passed through RPC middleware.
+ * @public
+ */
+export type AztecWalletContext = Record<string, unknown> & {
+  /** The PXE instance for the wallet */
+  pxe: PXE;
+  wallet: AccountWallet;
+  contractArtifactCache: ContractArtifactCache;
+};
+
+/**
+ * Type for Aztec Router Wallet middleware.
+ * @public
+ */
+export type AztecWalletMiddleware = JSONRPCMiddleware<AztecWalletBaseMethodMap, AztecWalletContext>;
+
+/**
+ * Type for Aztec Chain Wallet middleware.
+ */
+export type AztecChainWalletMiddleware = JSONRPCMiddleware<AztecWalletMethodMap, AztecWalletContext>;
+
+/**
+ * Type for Aztec wallet router client.
+ * @public
+ */
+export type AztecWalletRouterClient = JSONRPCWalletClient<AztecWalletMethodMap>;
+
+/**
+ * Type for Aztec wallet RPC method map.
+ * This extends the AztecWalletBaseMethodMap with the methods used in by Aztec's `AccountWallet`
+ */
+export interface AztecWalletMethodMap extends AztecWalletBaseMethodMap {
+  /* Chain */
+  aztec_getBlock: { params: { number: number }; result: L2Block };
+  aztec_getBlockNumber: { result: number };
+  aztec_getChainId: { result: number };
+  aztec_getVersion: { result: number };
+  aztec_getNodeInfo: { result: NodeInfo };
+  aztec_getProvenBlockNumber: { result: number };
+  aztec_getPXEInfo: { result: PXEInfo };
+  aztec_getCurrentBaseFees: { result: GasFees };
+
+  /* Scopes */
+  aztec_setScopes: { params: { scopes: AztecAddress[] }; result: boolean };
+  aztec_getScopes: { result: AztecAddress[] };
+
+  /* L1->L2 Messages */
+  aztec_isL1ToL2MessageSynced: { params: { l1ToL2Message: Fr }; result: boolean };
+  aztec_getL1ToL2MembershipWitness: {
+    params: { contractAddress: AztecAddress; messageHash: Fr; secret: Fr };
+    result: [bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>];
+  };
+
+  /* Capsules */
+  aztec_addCapsule: { params: { capsule: Fr[] }; result: boolean };
+
+  /* Accounts */
+  aztec_getAddress: { result: AztecAddress };
+  aztec_getCompleteAddress: { result: CompleteAddress };
+  aztec_registerAccount: {
+    params: { secretKey: Fr; partialAddress: PartialAddress };
+    result: CompleteAddress;
+  };
+  aztec_getRegisteredAccounts: { result: CompleteAddress[] };
+
+  /* AuthWitness */
+  aztec_addAuthWitness: { params: { authWitness: AuthWitness }; result: boolean };
+  aztec_getAuthWitness: { params: { messageHash: Fr }; result: Fr[] };
+  aztec_createAuthWit: {
+    params: { intent: Fr | Buffer | IntentAction | IntentInnerHash };
+    result: AuthWitness;
+  };
+
+  /* Senders */
+
+  /**
+   * Registers a contact in the user's PXE
+   * @param params - The sender (contact) address to register
+   * @returns True if registration was successful
+   */
+  aztec_registerSender: { params: { sender: AztecAddress }; result: AztecAddress };
+  aztec_getSenders: { result: AztecAddress[] };
+  aztec_removeSender: { params: { sender: AztecAddress }; result: boolean };
+
+  /* Contracts */
+
+  aztec_getContracts: { result: AztecAddress[] };
+  aztec_getContractInstance: { params: { address: AztecAddress }; result: ContractInstanceWithAddress };
+  aztec_getContractClass: { params: { id: Fr }; result: ContractClassWithId };
+  aztec_getContractArtifact: { params: { id: Fr }; result: ContractArtifact };
+  aztec_isContractClassPubliclyRegistered: { params: { id: Fr }; result: boolean };
+  aztec_isContractPubliclyDeployed: { params: { address: AztecAddress }; result: boolean };
+  aztec_isContractInitialized: { params: { address: AztecAddress }; result: boolean };
+
+  /**
+   * Registers a contract instance in the user's PXE.
+   * @param params - The contract details to register
+   * @returns True if registration was successful
+   */
+  aztec_registerContract: {
+    params: { instance: ContractInstanceWithAddress; artifact?: ContractArtifact };
+    result: boolean;
+  };
+
+  /**
+   * Registers a contract class in the user's PXE.
+   * @param params - The contract artifact to register
+   * @returns True if registration was successful
+   */
+  aztec_registerContractClass: { params: { artifact: ContractArtifact }; result: boolean };
+  // biome-ignore lint/suspicious/noExplicitAny: return type from aztec.js is `any`
+  aztec_getPublicStorageAt: { params: { contract: AztecAddress; storageSlot: Fr }; result: any };
+
+  /* Transactions */
+  aztec_sendTx: { params: { tx: Tx }; result: TxHash };
+  aztec_createTxExecutionRequest: { params: { exec: ExecutionRequestInit }; result: TxExecutionRequest };
+  aztec_proveTx: {
+    params: { txRequest: TxExecutionRequest; privateExecutionResult: PrivateExecutionResult };
+    result: TxProvingResult;
+  };
+  aztec_getTxEffect: { params: { txHash: TxHash }; result: InBlock<TxEffect> };
+  aztec_getTxReceipt: { params: { txHash: TxHash }; result: TxReceipt };
+
+  aztec_simulateTx: {
+    params: {
+      txRequest: TxExecutionRequest;
+      simulatePublic: boolean;
+      msgSender?: AztecAddress;
+      skipTxValidation?: boolean;
+      enforceFeePayment?: boolean;
+      profile?: boolean;
+    };
+    result: TxSimulationResult;
+  };
+  aztec_simulateUnconstrained: {
+    params: { functionName: string; args: unknown[]; to: AztecAddress; from?: AztecAddress };
+    result: AbiDecoded;
+  };
+
+  /* Notes */
+  aztec_getIncomingNotes: { params: { filter: IncomingNotesFilter }; result: UniqueNote[] };
+  aztec_addNote: { params: { note: ExtendedNote }; result: boolean };
+  aztec_addNullifiedNote: { params: { note: ExtendedNote }; result: boolean };
+
+  /* Logs */
+  aztec_getUnencryptedLogs: { params: { filter: LogFilter }; result: GetUnencryptedLogsResponse };
+  aztec_getContractClassLogs: { params: { filter: LogFilter }; result: GetUnencryptedLogsResponse };
+  aztec_getEncryptedEvents: {
+    params: { event: EventMetadataDefinition; from: number; limit: number; vpks?: Point[] };
+    result: unknown[];
+  };
+  aztec_getUnencryptedEvents: {
+    params: { event: EventMetadataDefinition; from: number; limit: number };
+    result: unknown[];
+  };
+}
+
+export type AztecWalletMethodHandler<
+  T extends AztecWalletMethodMap,
+  M extends keyof T,
+  C extends AztecWalletContext,
+> = (
+  context: C,
+  params: T[M]['params'],
+  accountWallet: AccountWallet,
+) => Promise<T[M]['result']> | T[M]['result'];
+
+export type AztecChainId = `aztec:${string}`;