@walletmesh/aztec-rpc-wallet 0.3.1 → 0.4.0

package/src/wallet/handlers/transaction.test.ts

@@ -0,0 +1,371 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createTransactionHandlers } from './transaction.js';
+import type { AccountWallet, PXE, AztecAddress, TxHash, AuthWitness } from '@aztec/aztec.js';
+import type { TxExecutionRequest, Tx, TxReceipt } from '@aztec/aztec.js';
+// import type { FeeOptions, TxExecutionOptions } from '@aztec/entrypoints/interfaces'; // Unused
+// import type { ExecutionPayload } from '@aztec/entrypoints/payload'; // Unused
+import type { AztecHandlerContext } from './index.js';
+import type { ContractArtifactCache } from '../../contractArtifactCache.js';
+import { Fr } from '@aztec/aztec.js';
+import type {
+  PrivateExecutionResult,
+  TxProvingResult,
+  TxSimulationResult,
+  TxProfileResult,
+  UtilitySimulationResult,
+} from '@aztec/stdlib/tx';
+
+// Mock dependencies
+const createMockWallet = () =>
+  ({
+    createTxExecutionRequest: vi.fn(),
+    proveTx: vi.fn(),
+    sendTx: vi.fn(),
+    getTxReceipt: vi.fn(),
+    simulateTx: vi.fn(),
+    profileTx: vi.fn(),
+    simulateUtility: vi.fn(),
+  }) as unknown as AccountWallet;
+
+const createMockPXE = () =>
+  ({
+    // No specific methods needed for transaction handlers
+  }) as unknown as PXE;
+
+const createMockContext = (wallet: AccountWallet, pxe: PXE): AztecHandlerContext => ({
+  wallet,
+  pxe,
+  cache: {} as ContractArtifactCache,
+});
+
+describe('Transaction Handlers', () => {
+  let mockWallet: AccountWallet;
+  let mockPXE: PXE;
+  let context: AztecHandlerContext;
+  let handlers: ReturnType<typeof createTransactionHandlers>;
+
+  beforeEach(() => {
+    mockWallet = createMockWallet();
+    mockPXE = createMockPXE();
+    context = createMockContext(mockWallet, mockPXE);
+    handlers = createTransactionHandlers();
+  });
+
+  describe('aztec_proveTx', () => {
+    it('should prove transaction with request and execution result', async () => {
+      const txRequest = {
+        txRequest: { exec: { calls: [] } },
+      } as unknown as TxExecutionRequest;
+      const privateExecutionResult = {
+        executionResults: [],
+        gasUsed: { l2Gas: 50000, daGas: 2500 },
+        entrypoint: undefined,
+        firstNullifier: undefined,
+        publicFunctionCalldata: undefined,
+        getSimulationBlockNumber: vi.fn(),
+      } as unknown as PrivateExecutionResult;
+
+      const expectedTx = {
+        hash: '0xabcdef1234567890',
+        data: Buffer.from('proven transaction data'),
+        privateExecutionResult: {},
+        publicInputs: {},
+        toTx: vi.fn(),
+      } as unknown as TxProvingResult;
+
+      vi.mocked(mockWallet.proveTx).mockResolvedValue(expectedTx);
+
+      const result = await handlers.aztec_proveTx(context, [txRequest, privateExecutionResult]);
+
+      expect(mockWallet.proveTx).toHaveBeenCalledWith(txRequest, privateExecutionResult);
+      expect(result).toBe(expectedTx);
+    });
+
+    it('should propagate errors from wallet.proveTx', async () => {
+      const txRequest = {} as unknown as TxExecutionRequest;
+      const privateExecutionResult = {} as unknown as PrivateExecutionResult;
+      const error = new Error('Failed to prove transaction');
+      vi.mocked(mockWallet.proveTx).mockRejectedValue(error);
+
+      await expect(handlers.aztec_proveTx(context, [txRequest, privateExecutionResult])).rejects.toThrow(
+        'Failed to prove transaction',
+      );
+      expect(mockWallet.proveTx).toHaveBeenCalledWith(txRequest, privateExecutionResult);
+    });
+  });
+
+  describe('aztec_sendTx', () => {
+    it('should send transaction and return transaction hash', async () => {
+      const tx = {
+        getTxHash: () => '0xabcdef1234567890' as unknown as TxHash,
+        data: Buffer.from('transaction data'),
+        toJSON: () => ({
+          hash: '0xabcdef1234567890',
+          data: 'transaction data',
+        }),
+      } as unknown as Tx;
+
+      const expectedTxHash = '0xabcdef1234567890' as unknown as TxHash;
+      vi.mocked(mockWallet.sendTx).mockResolvedValue(expectedTxHash);
+
+      const result = await handlers.aztec_sendTx(context, [tx]);
+
+      expect(mockWallet.sendTx).toHaveBeenCalledWith(tx);
+      expect(result).toBe(expectedTxHash);
+    });
+
+    it('should propagate errors from wallet.sendTx', async () => {
+      const tx = {
+        getTxHash: () => '0xabcdef1234567890' as unknown as TxHash,
+        toJSON: () => ({
+          hash: '0xabcdef1234567890',
+        }),
+      } as unknown as Tx;
+      const error = new Error('Failed to send transaction');
+      vi.mocked(mockWallet.sendTx).mockRejectedValue(error);
+
+      await expect(handlers.aztec_sendTx(context, [tx])).rejects.toThrow('Failed to send transaction');
+      expect(mockWallet.sendTx).toHaveBeenCalledWith(tx);
+    });
+  });
+
+  describe('aztec_getTxReceipt', () => {
+    it('should get transaction receipt for given hash', async () => {
+      const txHash = '0xabcdef1234567890' as unknown as TxHash;
+      const expectedReceipt = {
+        txHash,
+        status: 'mined',
+        blockNumber: 42,
+        blockHash: '0x1234567890abcdef',
+      } as unknown as TxReceipt;
+
+      vi.mocked(mockWallet.getTxReceipt).mockResolvedValue(expectedReceipt);
+
+      const result = await handlers.aztec_getTxReceipt(context, [txHash]);
+
+      expect(mockWallet.getTxReceipt).toHaveBeenCalledWith(txHash);
+      expect(result).toBe(expectedReceipt);
+    });
+
+    it('should handle null receipt for pending transaction', async () => {
+      const txHash = '0xabcdef1234567890' as unknown as TxHash;
+      vi.mocked(mockWallet.getTxReceipt).mockResolvedValue(null as unknown as TxReceipt);
+
+      const result = await handlers.aztec_getTxReceipt(context, [txHash]);
+
+      expect(mockWallet.getTxReceipt).toHaveBeenCalledWith(txHash);
+      expect(result).toBe(null);
+    });
+
+    it('should propagate errors from wallet.getTxReceipt', async () => {
+      const txHash = '0xabcdef1234567890' as unknown as TxHash;
+      const error = new Error('Failed to get transaction receipt');
+      vi.mocked(mockWallet.getTxReceipt).mockRejectedValue(error);
+
+      await expect(handlers.aztec_getTxReceipt(context, [txHash])).rejects.toThrow(
+        'Failed to get transaction receipt',
+      );
+      expect(mockWallet.getTxReceipt).toHaveBeenCalledWith(txHash);
+    });
+  });
+
+  describe('aztec_simulateTx', () => {
+    it('should simulate transaction with all parameters', async () => {
+      const txRequest = {
+        txRequest: { exec: { calls: [] } },
+      } as unknown as TxExecutionRequest;
+      const simulatePublic = true;
+      const msgSender = '0x1234567890abcdef' as unknown as AztecAddress;
+      const skipTxValidation = true;
+      const skipFeeEnforcement = true;
+
+      const expectedSimulation = {
+        txRequest,
+        publicOutput: {},
+        gasUsed: { l2Gas: 50000, daGas: 2500 },
+      } as unknown as TxSimulationResult;
+
+      vi.mocked(mockWallet.simulateTx).mockResolvedValue(expectedSimulation);
+
+      const result = await handlers.aztec_simulateTx(context, [
+        txRequest,
+        simulatePublic,
+        msgSender,
+        skipTxValidation,
+        skipFeeEnforcement,
+      ]);
+
+      expect(mockWallet.simulateTx).toHaveBeenCalledWith(
+        txRequest,
+        simulatePublic,
+        msgSender,
+        skipTxValidation,
+        skipFeeEnforcement,
+      );
+      expect(result).toBe(expectedSimulation);
+    });
+
+    it('should simulate transaction with default parameters', async () => {
+      const txRequest = {
+        txRequest: { exec: { calls: [] } },
+      } as unknown as TxExecutionRequest;
+
+      const expectedSimulation = {
+        txRequest,
+        publicOutput: {},
+        gasUsed: { l2Gas: 50000, daGas: 2500 },
+      } as unknown as TxSimulationResult;
+
+      vi.mocked(mockWallet.simulateTx).mockResolvedValue(expectedSimulation);
+
+      const result = await handlers.aztec_simulateTx(context, [
+        txRequest,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+      ]);
+
+      expect(mockWallet.simulateTx).toHaveBeenCalledWith(txRequest, false, undefined, undefined, false);
+      expect(result).toBe(expectedSimulation);
+    });
+
+    it('should propagate errors from wallet.simulateTx', async () => {
+      const txRequest = {} as unknown as TxExecutionRequest;
+      const error = new Error('Simulation failed');
+      vi.mocked(mockWallet.simulateTx).mockRejectedValue(error);
+
+      await expect(
+        handlers.aztec_simulateTx(context, [txRequest, undefined, undefined, undefined, undefined]),
+      ).rejects.toThrow('Simulation failed');
+      expect(mockWallet.simulateTx).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('aztec_profileTx', () => {
+    it('should profile transaction with all parameters', async () => {
+      const txRequest = {
+        txRequest: { exec: { calls: [] } },
+      } as unknown as TxExecutionRequest;
+      const profileMode = 'full' as const;
+      const skipProofGeneration = true;
+      const msgSender = '0x1234567890abcdef' as unknown as AztecAddress;
+
+      const expectedProfile = {
+        txRequest,
+        executionSteps: [],
+        timings: { totalTime: 1000 },
+        profile: { totalTime: 1000, gates: 50000 },
+      } as unknown as TxProfileResult;
+
+      vi.mocked(mockWallet.profileTx).mockResolvedValue(expectedProfile);
+
+      const result = await handlers.aztec_profileTx(context, [
+        txRequest,
+        profileMode,
+        skipProofGeneration,
+        msgSender,
+      ]);
+
+      expect(mockWallet.profileTx).toHaveBeenCalledWith(
+        txRequest,
+        profileMode,
+        skipProofGeneration,
+        msgSender,
+      );
+      expect(result).toBe(expectedProfile);
+    });
+
+    it('should profile transaction with default parameters', async () => {
+      const txRequest = {
+        txRequest: { exec: { calls: [] } },
+      } as unknown as TxExecutionRequest;
+
+      const expectedProfile = {
+        txRequest,
+        executionSteps: [],
+        timings: {},
+        profile: { gates: 50000 },
+      } as unknown as TxProfileResult;
+
+      vi.mocked(mockWallet.profileTx).mockResolvedValue(expectedProfile);
+
+      const result = await handlers.aztec_profileTx(context, [txRequest, undefined, undefined, undefined]);
+
+      expect(mockWallet.profileTx).toHaveBeenCalledWith(txRequest, 'gates', undefined, undefined);
+      expect(result).toBe(expectedProfile);
+    });
+
+    it('should propagate errors from wallet.profileTx', async () => {
+      const txRequest = {} as unknown as TxExecutionRequest;
+      const error = new Error('Profiling failed');
+      vi.mocked(mockWallet.profileTx).mockRejectedValue(error);
+
+      await expect(
+        handlers.aztec_profileTx(context, [txRequest, undefined, undefined, undefined]),
+      ).rejects.toThrow('Profiling failed');
+      expect(mockWallet.profileTx).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('aztec_simulateUtility', () => {
+    it('should simulate utility function with all parameters', async () => {
+      const functionName = 'testUtility';
+      const args = [new Fr(0x123n), new Fr(0x456n)];
+      const to = '0x1234567890abcdef' as unknown as AztecAddress;
+      const authWits = [{ witness: [new Fr(1n)] } as unknown as AuthWitness];
+      const from = '0xabcdef1234567890' as unknown as AztecAddress;
+
+      const expectedResult = {
+        result: new Fr(0x789n),
+        returnValue: new Fr(0x789n),
+        gasUsed: { l2Gas: 10000, daGas: 500 },
+      } as unknown as UtilitySimulationResult;
+
+      vi.mocked(mockWallet.simulateUtility).mockResolvedValue(expectedResult);
+
+      const result = await handlers.aztec_simulateUtility(context, [functionName, args, to, authWits, from]);
+
+      expect(mockWallet.simulateUtility).toHaveBeenCalledWith(functionName, args, to, authWits, from);
+      expect(result).toBe(expectedResult);
+    });
+
+    it('should simulate utility function with minimal parameters', async () => {
+      const functionName = 'simpleUtility';
+      const args: Fr[] = [];
+      const to = '0x1234567890abcdef' as unknown as AztecAddress;
+
+      const expectedResult = {
+        result: new Fr(0x0n),
+        returnValue: new Fr(0x0n),
+        gasUsed: { l2Gas: 5000, daGas: 250 },
+      } as unknown as UtilitySimulationResult;
+
+      vi.mocked(mockWallet.simulateUtility).mockResolvedValue(expectedResult);
+
+      const result = await handlers.aztec_simulateUtility(context, [
+        functionName,
+        args,
+        to,
+        undefined,
+        undefined,
+      ]);
+
+      expect(mockWallet.simulateUtility).toHaveBeenCalledWith(functionName, args, to, undefined, undefined);
+      expect(result).toBe(expectedResult);
+    });
+
+    it('should propagate errors from wallet.simulateUtility', async () => {
+      const functionName = 'failingUtility';
+      const args: Fr[] = [];
+      const to = '0x1234567890abcdef' as unknown as AztecAddress;
+      const error = new Error('Utility simulation failed');
+      vi.mocked(mockWallet.simulateUtility).mockRejectedValue(error);
+
+      await expect(
+        handlers.aztec_simulateUtility(context, [functionName, args, to, undefined, undefined]),
+      ).rejects.toThrow('Utility simulation failed');
+      expect(mockWallet.simulateUtility).toHaveBeenCalledWith(functionName, args, to, undefined, undefined);
+    });
+  });
+});

package/src/wallet/handlers/transaction.ts

@@ -0,0 +1,239 @@
+import type { AztecHandlerContext } from './index.js';
+import type { AztecWalletMethodMap } from '../../types.js';
+import { createLogger } from '@aztec/foundation/log';
+
+const logger = createLogger('aztec-rpc-wallet:transaction');
+
+/**
+ * Creates handlers for transaction-related Aztec wallet JSON-RPC methods.
+ * These handlers are responsible for the core lifecycle of an Aztec transaction,
+ * including proving, sending, simulating, and retrieving receipts.
+ *
+ * Each handler function receives an {@link AztecHandlerContext}, providing access to the
+ * {@link AccountWallet} and {@link PXE} client instances necessary for these operations.
+ *
+ * @returns An object where keys are transaction-related method names
+ *          (e.g., "aztec_proveTx", "aztec_sendTx") and values are their
+ *          corresponding handler functions.
+ * @see {@link AztecWalletMethodMap} for method definitions.
+ */
+export function createTransactionHandlers() {
+  return {
+    /**
+     * Handles the "aztec_proveTx" JSON-RPC method.
+     * Generates zero-knowledge proofs for a given {@link TxExecutionRequest}.
+     * If the {@link PrivateExecutionResult} is not provided, this handler will first
+     * simulate the private execution of the transaction to obtain it.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the transaction execution request and an optional private execution result.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_proveTx.params}.
+     * @param paramsTuple.0 - The {@link TxExecutionRequest} to prove.
+     * @param paramsTuple.1 - Optional: The {@link PrivateExecutionResult} from a prior private simulation.
+     *                        If not provided, a private simulation will be performed internally.
+     * @returns A promise that resolves to the {@link TxProvingResult}, which includes the proven transaction.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_proveTx.result}.
+     * @throws {Error} If `txRequest` is missing, or if simulation is needed but fails to produce a `PrivateExecutionResult`.
+     */
+    aztec_proveTx: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_proveTx']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_proveTx']['result']> => {
+      let [txRequest, privateExecutionResult] = paramsTuple; // privateExecutionResult can now be undefined
+      logger.debug(`[HANDLER] aztec_proveTx: txRequest received = ${!!txRequest}`);
+      if (!txRequest) {
+        // Only txRequest is mandatory now
+        throw new Error('Invalid parameters received in tuple for aztec_proveTx: txRequest is missing');
+      }
+
+      if (!privateExecutionResult) {
+        logger.debug(
+          '[HANDLER] aztec_proveTx: privateExecutionResult not provided, simulating transaction first.',
+        );
+        // Simulate the private part of the transaction to get the PrivateExecutionResult
+        // Pass false for simulatePublic, as we only need the private execution.
+        // Pass undefined for msgSender, skipTxValidation, skipFeeEnforcement to use defaults.
+        const simulationResult = await ctx.wallet.simulateTx(
+          txRequest,
+          false,
+          undefined,
+          undefined,
+          undefined,
+        );
+        privateExecutionResult = simulationResult.privateExecutionResult;
+        if (!privateExecutionResult) {
+          throw new Error('Failed to obtain PrivateExecutionResult from simulation for aztec_proveTx');
+        }
+        logger.debug('[HANDLER] aztec_proveTx: privateExecutionResult obtained from simulation.');
+      }
+
+      return await ctx.wallet.proveTx(txRequest, privateExecutionResult);
+    },
+
+    /**
+     * Handles the "aztec_sendTx" JSON-RPC method.
+     * Sends a proven {@link Tx} (transaction object) to the Aztec network via the
+     * {@link AccountWallet} in the context.
+     *
+     * This is typically the final step in submitting a transaction after it has been
+     * successfully proven by `aztec_proveTx`.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the proven transaction.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_sendTx.params}.
+     * @param paramsTuple.0 - The proven {@link Tx} object to send.
+     * @returns A promise that resolves to the {@link TxHash} of the sent transaction.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_sendTx.result}.
+     * @throws {Error} If the `tx` parameter is missing or invalid.
+     */
+    aztec_sendTx: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_sendTx']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_sendTx']['result']> => {
+      const [tx] = paramsTuple;
+      logger.debug(`[HANDLER] aztec_sendTx: tx hash = ${tx?.getTxHash()?.toString()}`);
+      if (!tx) {
+        // tx is mandatory
+        throw new Error('Invalid tx parameter received in tuple');
+      }
+      return await ctx.wallet.sendTx(tx);
+    },
+
+    /**
+     * Handles the "aztec_getTxReceipt" JSON-RPC method.
+     * Retrieves the {@link TxReceipt} for a transaction identified by its {@link TxHash},
+     * using the {@link AccountWallet} in the context.
+     *
+     * The receipt provides information about the transaction's execution status
+     * (e.g., success, failure, reverted), block inclusion, and any emitted events.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the transaction hash.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_getTxReceipt.params}.
+     * @param paramsTuple.0 - The {@link TxHash} of the transaction.
+     * @returns A promise that resolves to the {@link TxReceipt}.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_getTxReceipt.result}.
+     * @throws {Error} If the `txHash` parameter is missing or invalid.
+     */
+    aztec_getTxReceipt: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_getTxReceipt']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_getTxReceipt']['result']> => {
+      const [txHash] = paramsTuple;
+      logger.debug(`[HANDLER] aztec_getTxReceipt: txHash = ${txHash?.toString()}`);
+      if (!txHash) {
+        // txHash is mandatory
+        throw new Error('Invalid txHash parameter received in tuple');
+      }
+      return await ctx.wallet.getTxReceipt(txHash);
+    },
+
+    /**
+     * Handles the "aztec_simulateTx" JSON-RPC method.
+     * Simulates the execution of a {@link TxExecutionRequest} without actually proving
+     * or sending it to the network. This is useful for estimating gas, verifying
+     * correctness, or debugging.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the parameters for simulation.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_simulateTx.params}.
+     * @param paramsTuple.0 - The {@link TxExecutionRequest} to simulate.
+     * @param paramsTuple.1 - Optional: Boolean indicating whether to simulate public parts of the transaction. Defaults to `false`.
+     * @param paramsTuple.2 - Optional: The {@link AztecAddress} of the message sender for simulation context.
+     * @param paramsTuple.3 - Optional: Boolean flag to skip transaction validation during simulation.
+     * @param paramsTuple.4 - Optional: Boolean flag to skip fee enforcement during simulation.
+     * @returns A promise that resolves to the {@link TxSimulationResult}.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_simulateTx.result}.
+     * @throws {Error} If the `txRequest` parameter is missing or invalid.
+     */
+    aztec_simulateTx: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_simulateTx']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_simulateTx']['result']> => {
+      const [
+        txRequest,
+        simulatePublicInput, // simulatePublic is optional in PXE interface
+        msgSender,
+        skipTxValidation,
+        skipFeeEnforcementInput, // skipFeeEnforcement is optional in PXE interface
+      ] = paramsTuple;
+      // Handle optional params with defaults if necessary, matching PXE behavior
+      const simulatePublic = simulatePublicInput === undefined ? false : simulatePublicInput;
+      const skipFeeEnforcement = skipFeeEnforcementInput === undefined ? false : skipFeeEnforcementInput;
+
+      logger.debug(`[HANDLER] aztec_simulateTx: txRequest received = ${!!txRequest}`);
+      if (!txRequest) {
+        // txRequest is mandatory
+        throw new Error('Invalid txRequest parameter received in tuple');
+      }
+      return await ctx.wallet.simulateTx(
+        txRequest,
+        simulatePublic,
+        msgSender,
+        skipTxValidation,
+        skipFeeEnforcement,
+      );
+    },
+
+    /**
+     * Handles the "aztec_profileTx" JSON-RPC method.
+     * Profiles a {@link TxExecutionRequest} to gather performance metrics, such as
+     * gate counts and execution steps, without sending it to the network.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the parameters for profiling.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_profileTx.params}.
+     * @param paramsTuple.0 - The {@link TxExecutionRequest} to profile.
+     * @param paramsTuple.1 - Optional: The profiling mode ('gates', 'execution-steps', or 'full'). Defaults to 'gates'.
+     * @param paramsTuple.2 - Optional: Boolean flag to skip proof generation during profiling.
+     * @param paramsTuple.3 - Optional: The {@link AztecAddress} of the message sender for profiling context.
+     * @returns A promise that resolves to the {@link TxProfileResult}.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_profileTx.result}.
+     * @throws {Error} If the `txRequest` parameter is missing or invalid.
+     */
+    aztec_profileTx: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_profileTx']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_profileTx']['result']> => {
+      const [txRequest, profileModeInput, skipProofGeneration, msgSender] = paramsTuple;
+      const profileMode = profileModeInput === undefined ? 'gates' : profileModeInput; // Default for optional
+
+      logger.debug(`[HANDLER] aztec_profileTx: txRequest received = ${!!txRequest}`);
+      if (!txRequest) {
+        // txRequest is mandatory
+        throw new Error('Invalid txRequest parameter received in tuple');
+      }
+      return await ctx.wallet.profileTx(txRequest, profileMode, skipProofGeneration, msgSender);
+    },
+
+    /**
+     * Handles the "aztec_simulateUtility" JSON-RPC method.
+     * Simulates a call to a utility (view) function on a contract. Utility functions
+     * are read-only and do not modify state or require a transaction.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the parameters for the utility function call.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_simulateUtility.params}.
+     * @param paramsTuple.0 - The name of the utility function to call.
+     * @param paramsTuple.1 - An array of arguments for the function call.
+     * @param paramsTuple.2 - The {@link AztecAddress} of the contract or account to call.
+     * @param paramsTuple.3 - Optional: An array of {@link AuthWitness} for authorization, if needed.
+     * @param paramsTuple.4 - Optional: The {@link AztecAddress} of the sender, if relevant for the utility call.
+     * @returns A promise that resolves to the {@link UtilitySimulationResult}.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_simulateUtility.result}.
+     * @throws {Error} If required parameters like `functionName`, `args`, or `to` are missing or invalid.
+     */
+    aztec_simulateUtility: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_simulateUtility']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_simulateUtility']['result']> => {
+      const [functionName, args, to, authWits, from] = paramsTuple;
+      logger.debug(`[HANDLER] aztec_simulateUtility: functionName = ${functionName}, to = ${to?.toString()}`);
+      if (!functionName || !args || !to) {
+        // Mandatory params
+        throw new Error('Invalid parameters received in tuple for aztec_simulateUtility');
+      }
+      return await ctx.wallet.simulateUtility(functionName, args, to, authWits, from);
+    },
+  };
+}