@walletmesh/aztec-rpc-wallet 0.1.0

package/src/handlers/aztecAccountWallet.test.ts

@@ -0,0 +1,720 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import type { AccountWallet } from '@aztec/aztec.js';
+import { Fr, AztecAddress, TxHash, ExtendedNote, EventSelector } from '@aztec/aztec.js';
+import type {
+  TxExecutionRequest,
+  ContractInstanceWithAddress,
+  ContractArtifact,
+  PublicKeys,
+  Note,
+  AuthWitness,
+  Tx,
+} from '@aztec/aztec.js';
+import type { PrivateExecutionResult, EventMetadataDefinition } from '@aztec/circuit-types';
+import type { IntentAction, IntentInnerHash } from '@aztec/aztec.js/utils';
+import { Point } from '@aztec/circuits.js';
+import type { AztecWalletMethodMap } from '../types.js';
+import { aztecWalletHandler } from './aztecAccountWallet.js';
+import { AztecWalletError } from '../errors.js';
+import type { AztecWalletContext } from '../types.js';
+
+describe('Aztec Account Wallet Handler', () => {
+  let context: AztecWalletContext;
+  let wallet: AccountWallet;
+
+  beforeEach(() => {
+    // Mock wallet with common methods
+    wallet = {
+      getBlock: vi.fn(),
+      getBlockNumber: vi.fn(),
+      getChainId: vi.fn(),
+      getVersion: vi.fn(),
+      getNodeInfo: vi.fn(),
+      getCurrentBaseFees: vi.fn(),
+      setScopes: vi.fn(),
+      getScopes: vi.fn(),
+      addCapsule: vi.fn(),
+      getAddress: vi.fn(),
+      getCompleteAddress: vi.fn(),
+      registerAccount: vi.fn(),
+      getRegisteredAccounts: vi.fn(),
+      registerSender: vi.fn(),
+      getSenders: vi.fn(),
+      removeSender: vi.fn(),
+      addAuthWitness: vi.fn(),
+      getAuthWitness: vi.fn(),
+      createAuthWit: vi.fn(),
+      isL1ToL2MessageSynced: vi.fn(),
+      getContracts: vi.fn(),
+      getContractInstance: vi.fn(),
+      getContractClass: vi.fn(),
+      getContractArtifact: vi.fn(),
+      isContractClassPubliclyRegistered: vi.fn(),
+      isContractPubliclyDeployed: vi.fn(),
+      isContractInitialized: vi.fn(),
+      registerContract: vi.fn(),
+      registerContractClass: vi.fn(),
+      getPublicStorageAt: vi.fn(),
+      createTxExecutionRequest: vi.fn(),
+      proveTx: vi.fn(),
+      sendTx: vi.fn(),
+      getTxEffect: vi.fn(),
+      getTxReceipt: vi.fn(),
+      simulateTx: vi.fn(),
+      simulateUnconstrained: vi.fn(),
+      getIncomingNotes: vi.fn(),
+      addNote: vi.fn(),
+      addNullifiedNote: vi.fn(),
+      getUnencryptedLogs: vi.fn(),
+      getContractClassLogs: vi.fn(),
+      getEncryptedEvents: vi.fn(),
+      getUnencryptedEvents: vi.fn(),
+      getL1ToL2MembershipWitness: vi.fn(),
+    } as unknown as AccountWallet;
+
+    context = { wallet } as AztecWalletContext;
+  });
+
+  describe('Chain Methods', () => {
+    it('handles aztec_getBlock', async () => {
+      const mockBlock = { number: 1, hash: '0x123' };
+      wallet.getBlock = vi.fn().mockResolvedValue(mockBlock);
+
+      const result = await aztecWalletHandler(context, 'aztec_getBlock', { number: 1 });
+      expect(result).toEqual(mockBlock);
+      expect(wallet.getBlock).toHaveBeenCalledWith(1);
+    });
+
+    it('throws error when block not found', async () => {
+      wallet.getBlock = vi.fn().mockResolvedValue(null);
+
+      await expect(aztecWalletHandler(context, 'aztec_getBlock', { number: 1 })).rejects.toThrow(
+        AztecWalletError,
+      );
+    });
+
+    it('handles aztec_getBlockNumber', async () => {
+      const mockBlockNumber = 100;
+      wallet.getBlockNumber = vi.fn().mockResolvedValue(mockBlockNumber);
+
+      const result = await aztecWalletHandler(context, 'aztec_getBlockNumber', {});
+      expect(result).toBe(mockBlockNumber);
+    });
+
+    it('handles aztec_getChainId', async () => {
+      wallet.getChainId = vi.fn().mockReturnValue(BigInt(1));
+
+      const result = await aztecWalletHandler(context, 'aztec_getChainId', {});
+      expect(result).toBe(1);
+    });
+
+    it('handles aztec_getVersion', async () => {
+      wallet.getVersion = vi.fn().mockReturnValue(BigInt(1));
+
+      const result = await aztecWalletHandler(context, 'aztec_getVersion', {});
+      expect(result).toBe(1);
+    });
+  });
+
+  describe('Scope Methods', () => {
+    it('handles aztec_setScopes', async () => {
+      const mockAddress = AztecAddress.random();
+      const scopes = [mockAddress];
+      wallet.setScopes = vi.fn().mockResolvedValue(undefined);
+
+      const result = await aztecWalletHandler(context, 'aztec_setScopes', { scopes });
+      expect(result).toBe(true);
+      expect(wallet.setScopes).toHaveBeenCalledWith(scopes);
+    });
+
+    it('handles aztec_getScopes', async () => {
+      const scopes = [AztecAddress.random(), AztecAddress.random()];
+      wallet.getScopes = vi.fn().mockResolvedValue(scopes);
+
+      const result = await aztecWalletHandler(context, 'aztec_getScopes', {});
+      expect(result).toEqual(scopes);
+    });
+
+    it('handles aztec_getScopes with null response', async () => {
+      wallet.getScopes = vi.fn().mockResolvedValue(null);
+
+      const result = await aztecWalletHandler(context, 'aztec_getScopes', {});
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('Account Methods', () => {
+    it('handles aztec_getAddress', async () => {
+      const mockAddress = AztecAddress.random();
+      wallet.getAddress = vi.fn().mockReturnValue(mockAddress);
+
+      const result = await aztecWalletHandler(context, 'aztec_getAddress', {});
+      expect(result).toBe(mockAddress);
+    });
+
+    it('handles aztec_getCompleteAddress', async () => {
+      const mockAddress = {
+        address: AztecAddress.random(),
+        publicKey: AztecAddress.random(),
+      };
+      wallet.getCompleteAddress = vi.fn().mockReturnValue(mockAddress);
+
+      const result = await aztecWalletHandler(context, 'aztec_getCompleteAddress', {});
+      expect(result).toBe(mockAddress);
+    });
+
+    it('handles aztec_registerAccount', async () => {
+      const mockParams = { secretKey: new Fr(1), partialAddress: new Fr(2) };
+      const mockResult = { address: AztecAddress.random() };
+      wallet.registerAccount = vi.fn().mockResolvedValue(mockResult);
+
+      const result = await aztecWalletHandler(context, 'aztec_registerAccount', mockParams);
+      expect(result).toBe(mockResult);
+      expect(wallet.registerAccount).toHaveBeenCalledWith(mockParams.secretKey, mockParams.partialAddress);
+    });
+  });
+
+  describe('Node Info Methods', () => {
+    it('handles aztec_getNodeInfo', async () => {
+      const mockNodeInfo = { version: '1.0.0', status: 'running' };
+      wallet.getNodeInfo = vi.fn().mockResolvedValue(mockNodeInfo);
+
+      const result = await aztecWalletHandler(context, 'aztec_getNodeInfo', {});
+      expect(result).toBe(mockNodeInfo);
+    });
+
+    it('handles aztec_getCurrentBaseFees', async () => {
+      const mockFees = { baseFee: BigInt(1000) };
+      wallet.getCurrentBaseFees = vi.fn().mockResolvedValue(mockFees);
+
+      const result = await aztecWalletHandler(context, 'aztec_getCurrentBaseFees', {});
+      expect(result).toBe(mockFees);
+    });
+  });
+
+  describe('L1->L2 Message Methods', () => {
+    it('handles aztec_isL1ToL2MessageSynced', async () => {
+      const mockMessage = Fr.random();
+      wallet.isL1ToL2MessageSynced = vi.fn().mockResolvedValue(true);
+
+      const result = await aztecWalletHandler(context, 'aztec_isL1ToL2MessageSynced', {
+        l1ToL2Message: mockMessage,
+      });
+      expect(result).toBe(true);
+    });
+
+    it('handles aztec_getL1ToL2MembershipWitness', async () => {
+      const mockParams = {
+        contractAddress: AztecAddress.random(),
+        messageHash: Fr.random(),
+        secret: Fr.random(),
+      };
+      const mockWitness = { witness: new Uint8Array([1, 2, 3]) };
+      wallet.getL1ToL2MembershipWitness = vi.fn().mockResolvedValue(mockWitness);
+
+      const result = await aztecWalletHandler(context, 'aztec_getL1ToL2MembershipWitness', mockParams);
+      expect(result).toBe(mockWitness);
+      expect(wallet.getL1ToL2MembershipWitness).toHaveBeenCalledWith(
+        mockParams.contractAddress,
+        mockParams.messageHash,
+        mockParams.secret,
+      );
+    });
+  });
+
+  describe('Note Methods', () => {
+    it('handles aztec_getIncomingNotes', async () => {
+      const mockFilter = { contractAddress: AztecAddress.random() };
+      const mockNotes = [ExtendedNote.random()];
+      wallet.getIncomingNotes = vi.fn().mockResolvedValue(mockNotes);
+
+      const result = await aztecWalletHandler(context, 'aztec_getIncomingNotes', { filter: mockFilter });
+      expect(result).toBe(mockNotes);
+    });
+
+    it('handles aztec_addNote', async () => {
+      const mockNote = ExtendedNote.random();
+      wallet.addNote = vi.fn().mockResolvedValue(undefined);
+
+      const result = await aztecWalletHandler(context, 'aztec_addNote', { note: mockNote });
+      expect(result).toBe(true);
+      expect(wallet.addNote).toHaveBeenCalledWith(mockNote);
+    });
+
+    it('handles aztec_addNullifiedNote', async () => {
+      const mockNote = ExtendedNote.random();
+      Object.assign(mockNote, { nullified: true });
+      wallet.addNullifiedNote = vi.fn().mockResolvedValue(undefined);
+
+      const result = await aztecWalletHandler(context, 'aztec_addNullifiedNote', { note: mockNote });
+      expect(result).toBe(true);
+      expect(wallet.addNullifiedNote).toHaveBeenCalledWith(mockNote);
+    });
+  });
+
+  describe('Contract Methods', () => {
+    it('handles aztec_getContractInstance', async () => {
+      const mockAddress = AztecAddress.random();
+      const mockInstance = {
+        address: mockAddress,
+        toString: () => mockAddress.toString(),
+      } as unknown as ContractInstanceWithAddress;
+      wallet.getContractInstance = vi.fn().mockResolvedValue(mockInstance);
+
+      const result = await aztecWalletHandler(context, 'aztec_getContractInstance', { address: mockAddress });
+      expect(result).toBe(mockInstance);
+    });
+
+    it('throws error when contract instance not found', async () => {
+      wallet.getContractInstance = vi.fn().mockResolvedValue(null);
+
+      const testAddress = AztecAddress.random();
+      await expect(
+        aztecWalletHandler(context, 'aztec_getContractInstance', { address: testAddress }),
+      ).rejects.toThrow(AztecWalletError);
+    });
+
+    it('handles aztec_getContractClass', async () => {
+      const mockId = Fr.random();
+      const mockContractClass = { id: mockId };
+      wallet.getContractClass = vi.fn().mockResolvedValue(mockContractClass);
+
+      const result = await aztecWalletHandler(context, 'aztec_getContractClass', { id: mockId });
+      expect(result).toBe(mockContractClass);
+    });
+
+    it('throws error when contract class not found', async () => {
+      wallet.getContractClass = vi.fn().mockResolvedValue(null);
+      const mockId = Fr.random();
+
+      await expect(aztecWalletHandler(context, 'aztec_getContractClass', { id: mockId })).rejects.toThrow(
+        AztecWalletError,
+      );
+    });
+
+    it('handles aztec_getContractArtifact', async () => {
+      const mockId = Fr.random();
+      const mockArtifact = { id: mockId, name: 'TestContract' };
+      wallet.getContractArtifact = vi.fn().mockResolvedValue(mockArtifact);
+
+      const result = await aztecWalletHandler(context, 'aztec_getContractArtifact', { id: mockId });
+      expect(result).toBe(mockArtifact);
+    });
+
+    it('throws error when contract artifact not found', async () => {
+      wallet.getContractArtifact = vi.fn().mockResolvedValue(null);
+      const mockId = Fr.random();
+
+      await expect(aztecWalletHandler(context, 'aztec_getContractArtifact', { id: mockId })).rejects.toThrow(
+        AztecWalletError,
+      );
+    });
+
+    it('handles aztec_isContractClassPubliclyRegistered', async () => {
+      const mockId = Fr.random();
+      wallet.isContractClassPubliclyRegistered = vi.fn().mockResolvedValue(true);
+
+      const result = await aztecWalletHandler(context, 'aztec_isContractClassPubliclyRegistered', {
+        id: mockId,
+      });
+      expect(result).toBe(true);
+    });
+
+    it('handles aztec_isContractPubliclyDeployed', async () => {
+      const mockAddress = AztecAddress.random();
+      wallet.isContractPubliclyDeployed = vi.fn().mockResolvedValue(true);
+
+      const result = await aztecWalletHandler(context, 'aztec_isContractPubliclyDeployed', {
+        address: mockAddress,
+      });
+      expect(result).toBe(true);
+    });
+
+    it('handles aztec_isContractInitialized', async () => {
+      const mockAddress = AztecAddress.random();
+      wallet.isContractInitialized = vi.fn().mockResolvedValue(true);
+
+      const result = await aztecWalletHandler(context, 'aztec_isContractInitialized', {
+        address: mockAddress,
+      });
+      expect(result).toBe(true);
+    });
+
+    it('handles aztec_registerContract', async () => {
+      const mockAddress = AztecAddress.random();
+      const mockPublicKeys = {
+        masterNullifierPublicKey: new Fr(1),
+        masterIncomingViewingPublicKey: new Fr(2),
+        masterOutgoingViewingPublicKey: new Fr(3),
+        masterTaggingPublicKey: new Fr(4),
+        masterClaimingPublicKey: new Fr(5),
+        masterNoteHashingPublicKey: new Fr(6),
+        masterNoteCommitmentPublicKey: new Fr(7),
+        masterNullifierGeneratorPublicKey: new Fr(8),
+        masterTaggingGeneratorPublicKey: new Fr(9),
+        masterClaimingGeneratorPublicKey: new Fr(10),
+        hash: () => new Fr(11),
+        isEmpty: () => false,
+        equals: () => false,
+        toBuffer: () => new Uint8Array(),
+        toString: () => 'mockPublicKeys',
+        toJSON: () => ({}),
+      } as unknown as PublicKeys;
+
+      const mockInstance = {
+        address: mockAddress,
+        version: 1,
+        salt: new Fr(2),
+        deployer: mockAddress,
+        contractClassId: new Fr(3),
+        initializationHash: new Fr(4),
+        publicKeys: mockPublicKeys,
+      } as unknown as ContractInstanceWithAddress;
+
+      const mockArtifact = {
+        name: 'TestContract',
+        functions: {
+          test: {
+            name: 'test',
+            parameters: [],
+          },
+        },
+        outputs: {
+          structs: {},
+          globals: {},
+        },
+        storageLayout: {
+          structs: {},
+          globals: {},
+        },
+        notes: {},
+        fileMap: {},
+      } as unknown as ContractArtifact;
+      const mockParams = {
+        instance: mockInstance,
+        artifact: mockArtifact,
+      };
+      wallet.registerContract = vi.fn().mockResolvedValue(undefined);
+
+      const result = await aztecWalletHandler(context, 'aztec_registerContract', mockParams);
+      expect(result).toBe(true);
+      expect(wallet.registerContract).toHaveBeenCalledWith(mockParams);
+    });
+  });
+
+  describe('Log Methods', () => {
+    it('handles aztec_getUnencryptedLogs', async () => {
+      const mockFilter = { contractAddress: AztecAddress.random() };
+      const mockLogs = [{ data: new Uint8Array([1, 2, 3]) }];
+      wallet.getUnencryptedLogs = vi.fn().mockResolvedValue(mockLogs);
+
+      const result = await aztecWalletHandler(context, 'aztec_getUnencryptedLogs', { filter: mockFilter });
+      expect(result).toBe(mockLogs);
+    });
+
+    it('handles aztec_getContractClassLogs', async () => {
+      const mockFilter = { contractAddress: AztecAddress.random() };
+      const mockLogs = [{ data: new Uint8Array([1, 2, 3]) }];
+      wallet.getContractClassLogs = vi.fn().mockResolvedValue(mockLogs);
+
+      const result = await aztecWalletHandler(context, 'aztec_getContractClassLogs', { filter: mockFilter });
+      expect(result).toBe(mockLogs);
+    });
+
+    it('handles aztec_getEncryptedEvents', async () => {
+      const mockEvent = {
+        name: 'TestEvent',
+        parameters: [{ name: 'value', type: 'field' }],
+        returnType: { type: 'struct', items: [{ name: 'value', type: 'field' }] },
+        eventSelector: EventSelector.random(),
+        abiType: 'event',
+        fieldNames: ['value'],
+      } as unknown as EventMetadataDefinition;
+      const mockParams = {
+        event: mockEvent,
+        from: 0,
+        limit: 10,
+        vpks: [Point.random()],
+      };
+      const mockEvents = [{ data: new Uint8Array([1, 2, 3]) }];
+      wallet.getEncryptedEvents = vi.fn().mockResolvedValue(mockEvents);
+
+      const result = await aztecWalletHandler(context, 'aztec_getEncryptedEvents', mockParams);
+      expect(result).toBe(mockEvents);
+      expect(wallet.getEncryptedEvents).toHaveBeenCalledWith(
+        mockParams.event,
+        mockParams.from,
+        mockParams.limit,
+        mockParams.vpks,
+      );
+    });
+
+    it('handles aztec_getUnencryptedEvents', async () => {
+      const mockEvent = {
+        name: 'TestEvent',
+        parameters: [{ name: 'value', type: 'field' }],
+        returnType: { type: 'struct', items: [{ name: 'value', type: 'field' }] },
+        eventSelector: EventSelector.random(),
+        abiType: 'event',
+        fieldNames: ['value'],
+      } as unknown as EventMetadataDefinition;
+      const mockParams = {
+        event: mockEvent,
+        from: 0,
+        limit: 10,
+      };
+      const mockEvents = [{ data: new Uint8Array([1, 2, 3]) }];
+      wallet.getUnencryptedEvents = vi.fn().mockResolvedValue(mockEvents);
+
+      const result = await aztecWalletHandler(context, 'aztec_getUnencryptedEvents', mockParams);
+      expect(result).toBe(mockEvents);
+      expect(wallet.getUnencryptedEvents).toHaveBeenCalledWith(
+        mockParams.event,
+        mockParams.from,
+        mockParams.limit,
+      );
+    });
+  });
+
+  describe('Transaction Methods', () => {
+    it('handles aztec_getTxReceipt', async () => {
+      const mockTxHash = TxHash.random();
+      const mockReceipt = { status: 1 };
+      wallet.getTxReceipt = vi.fn().mockResolvedValue(mockReceipt);
+
+      const result = await aztecWalletHandler(context, 'aztec_getTxReceipt', { txHash: mockTxHash });
+      expect(result).toBe(mockReceipt);
+    });
+
+    it('throws error when transaction receipt not found', async () => {
+      wallet.getTxReceipt = vi.fn().mockResolvedValue(null);
+
+      const mockTxHash = TxHash.random();
+      await expect(aztecWalletHandler(context, 'aztec_getTxReceipt', { txHash: mockTxHash })).rejects.toThrow(
+        AztecWalletError,
+      );
+    });
+
+    it('handles aztec_simulateTx', async () => {
+      const mockParams = {
+        txRequest: {
+          origin: AztecAddress.random(),
+          functionSelector: new Fr(1),
+          firstCallArgsHash: new Fr(2),
+          txContext: {
+            chainId: 1,
+            version: 1,
+            protocolVersion: 1,
+            excessFeeReceiver: AztecAddress.random(),
+          },
+          callData: new Uint8Array(),
+          gasLimit: 1000000n,
+          gasPrice: 1000000n,
+          storageContractAddress: AztecAddress.random(),
+          portalContract: AztecAddress.random(),
+          argsOfCalls: [],
+          authWitnesses: [],
+          toTxRequest: () => ({ id: '0x123' }),
+          toBuffer: () => new Uint8Array(),
+        } as unknown as TxExecutionRequest,
+        simulatePublic: true,
+        msgSender: AztecAddress.random(),
+        skipTxValidation: false,
+        enforceFeePayment: true,
+        profile: true,
+      };
+      const mockResult = { success: true };
+      wallet.simulateTx = vi.fn().mockResolvedValue(mockResult);
+
+      const result = await aztecWalletHandler(context, 'aztec_simulateTx', mockParams);
+      expect(result).toBe(mockResult);
+      expect(wallet.simulateTx).toHaveBeenCalledWith(
+        mockParams.txRequest,
+        mockParams.simulatePublic,
+        mockParams.msgSender,
+        mockParams.skipTxValidation,
+        mockParams.enforceFeePayment,
+        mockParams.profile,
+      );
+    });
+  });
+
+  describe('Capsule Methods', () => {
+    it('handles aztec_addCapsule', async () => {
+      const mockCapsule = [Fr.random(), Fr.random(), Fr.random()];
+      wallet.addCapsule = vi.fn().mockResolvedValue(undefined);
+
+      const result = await aztecWalletHandler(context, 'aztec_addCapsule', { capsule: mockCapsule });
+      expect(result).toBe(true);
+      expect(wallet.addCapsule).toHaveBeenCalledWith(mockCapsule);
+    });
+  });
+
+  describe('Auth Witness Methods', () => {
+    it('handles aztec_addAuthWitness', async () => {
+      const mockAuthWitness = {
+        requestHash: Fr.random(),
+        witness: new Uint8Array([1, 2, 3]),
+        toJSON: () => ({}),
+        toBuffer: () => new Uint8Array([1, 2, 3]),
+      } as unknown as AuthWitness;
+      wallet.addAuthWitness = vi.fn().mockResolvedValue(undefined);
+
+      const result = await aztecWalletHandler(context, 'aztec_addAuthWitness', {
+        authWitness: mockAuthWitness,
+      });
+      expect(result).toBe(true);
+      expect(wallet.addAuthWitness).toHaveBeenCalledWith(mockAuthWitness);
+    });
+
+    it('handles aztec_createAuthWit', async () => {
+      const mockIntent = Fr.random() as unknown as IntentAction | IntentInnerHash;
+      const mockAuthWit = { witness: new Uint8Array([4, 5, 6]) };
+      wallet.createAuthWit = vi.fn().mockResolvedValue(mockAuthWit);
+
+      const result = await aztecWalletHandler(context, 'aztec_createAuthWit', { intent: mockIntent });
+      expect(result).toBe(mockAuthWit);
+      expect(wallet.createAuthWit).toHaveBeenCalledWith(mockIntent);
+    });
+  });
+
+  describe('Sender Methods', () => {
+    it('handles aztec_registerSender', async () => {
+      const mockSender = AztecAddress.random();
+      const mockResult = { success: true };
+      wallet.registerSender = vi.fn().mockResolvedValue(mockResult);
+
+      const result = await aztecWalletHandler(context, 'aztec_registerSender', { sender: mockSender });
+      expect(result).toBe(mockResult);
+      expect(wallet.registerSender).toHaveBeenCalledWith(mockSender);
+    });
+
+    it('handles aztec_removeSender', async () => {
+      const mockSender = AztecAddress.random();
+      wallet.removeSender = vi.fn().mockResolvedValue(undefined);
+
+      const result = await aztecWalletHandler(context, 'aztec_removeSender', { sender: mockSender });
+      expect(result).toBe(true);
+      expect(wallet.removeSender).toHaveBeenCalledWith(mockSender);
+    });
+  });
+
+  describe('Transaction Methods', () => {
+    it('handles aztec_proveTx', async () => {
+      const mockTxRequest = {
+        origin: AztecAddress.random(),
+        functionSelector: new Fr(1),
+        firstCallArgsHash: new Fr(2),
+        txContext: {
+          chainId: 1,
+          version: 1,
+          protocolVersion: 1,
+          excessFeeReceiver: AztecAddress.random(),
+        },
+        callData: new Uint8Array(),
+        gasLimit: 1000000n,
+        gasPrice: 1000000n,
+        storageContractAddress: AztecAddress.random(),
+        portalContract: AztecAddress.random(),
+        argsOfCalls: [],
+        authWitnesses: [],
+        toTxRequest: () => ({ id: '0x123' }),
+        toBuffer: () => new Uint8Array(),
+      } as unknown as TxExecutionRequest;
+      const mockPrivateExecutionResult = {
+        acir: new Uint8Array([1, 2, 3]),
+        vk: new Uint8Array([4, 5, 6]),
+        partialWitness: new Uint8Array([7, 8, 9]),
+        publicInputs: [Fr.random()],
+        success: true,
+        gasUsed: 1000n,
+        returnValue: new Uint8Array(),
+        unencryptedLogs: [],
+        contractClassLogs: [],
+        encryptedLogs: [],
+        encryptedLogPreimages: [],
+        encryptedLogKeys: [],
+      } as unknown as PrivateExecutionResult;
+      const mockProvenTx = { hash: TxHash.random() };
+      wallet.proveTx = vi.fn().mockResolvedValue(mockProvenTx);
+
+      const result = await aztecWalletHandler(context, 'aztec_proveTx', {
+        txRequest: mockTxRequest,
+        privateExecutionResult: mockPrivateExecutionResult,
+      });
+      expect(result).toBe(mockProvenTx);
+      expect(wallet.proveTx).toHaveBeenCalledWith(mockTxRequest, mockPrivateExecutionResult);
+    });
+
+    it('handles aztec_sendTx', async () => {
+      const mockTx = {
+        hash: TxHash.random(),
+        data: new Uint8Array([1, 2, 3]),
+        clientIvcProof: new Uint8Array([4, 5, 6]),
+        unencryptedLogs: [],
+        contractClassLogs: [],
+        encryptedLogs: [],
+        encryptedLogPreimages: [],
+        encryptedLogKeys: [],
+        encryptedLogsSalt: Fr.random(),
+        encryptedLogsCommitment: Fr.random(),
+        encryptedLogsTreeIndex: 0,
+        encryptedLogProofs: [],
+        encryptedLogProofsTreeIndex: 0,
+        encryptedLogProofsCommitment: Fr.random(),
+        encryptedLogProofsSalt: Fr.random(),
+        toBuffer: () => new Uint8Array(),
+        toString: () => 'mockTx',
+      } as unknown as Tx;
+      const mockTxHash = TxHash.random();
+      wallet.sendTx = vi.fn().mockResolvedValue(mockTxHash);
+
+      const result = await aztecWalletHandler(context, 'aztec_sendTx', { tx: mockTx });
+      expect(result).toBe(mockTxHash);
+      expect(wallet.sendTx).toHaveBeenCalledWith(mockTx);
+    });
+
+    it('handles aztec_getTxEffect', async () => {
+      const mockTxHash = TxHash.random();
+      const mockEffect = { success: true };
+      wallet.getTxEffect = vi.fn().mockResolvedValue(mockEffect);
+
+      const result = await aztecWalletHandler(context, 'aztec_getTxEffect', { txHash: mockTxHash });
+      expect(result).toBe(mockEffect);
+      expect(wallet.getTxEffect).toHaveBeenCalledWith(mockTxHash);
+    });
+
+    it('throws error when transaction effect not found', async () => {
+      wallet.getTxEffect = vi.fn().mockResolvedValue(null);
+
+      const mockTxHash = TxHash.random();
+      await expect(aztecWalletHandler(context, 'aztec_getTxEffect', { txHash: mockTxHash })).rejects.toThrow(
+        AztecWalletError,
+      );
+    });
+  });
+
+  describe('Public Storage Methods', () => {
+    it('handles aztec_getPublicStorageAt', async () => {
+      const mockContract = AztecAddress.random();
+      const mockStorageSlot = Fr.random();
+      const mockValue = Fr.random();
+      wallet.getPublicStorageAt = vi.fn().mockResolvedValue(mockValue);
+
+      const result = await aztecWalletHandler(context, 'aztec_getPublicStorageAt', {
+        contract: mockContract,
+        storageSlot: mockStorageSlot,
+      });
+      expect(result).toBe(mockValue);
+      expect(wallet.getPublicStorageAt).toHaveBeenCalledWith(mockContract, mockStorageSlot);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('throws error for unsupported method', async () => {
+      await expect(
+        aztecWalletHandler(context, 'not_a_real_method' as keyof AztecWalletMethodMap, {}),
+      ).rejects.toThrow(AztecWalletError);
+    });
+  });
+});