@walletmesh/aztec-rpc-wallet 0.3.0 → 0.4.0

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

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createContractHandlers } from './contract.js';
+import type { AccountWallet, PXE, AztecAddress } from '@aztec/aztec.js';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { ContractClassMetadata, ContractMetadata } from '@aztec/stdlib/interfaces/client';
+import type { AztecHandlerContext } from './index.js';
+import type { ContractArtifactCache } from '../../contractArtifactCache.js';
+import { Fr } from '@aztec/aztec.js';
+
+// Mock dependencies
+const createMockWallet = () =>
+  ({
+    registerContract: vi.fn(),
+    registerContractClass: vi.fn(),
+    getContractMetadata: vi.fn(),
+    getContractClassMetadata: vi.fn(),
+  }) as unknown as AccountWallet;
+
+const createMockPXE = () =>
+  ({
+    getContracts: vi.fn(),
+  }) as unknown as PXE;
+
+const createMockContext = (wallet: AccountWallet, pxe: PXE): AztecHandlerContext => ({
+  wallet,
+  pxe,
+  cache: {} as ContractArtifactCache,
+});
+
+describe('Contract Handlers', () => {
+  let mockWallet: AccountWallet;
+  let mockPXE: PXE;
+  let context: AztecHandlerContext;
+  let handlers: ReturnType<typeof createContractHandlers>;
+
+  beforeEach(() => {
+    mockWallet = createMockWallet();
+    mockPXE = createMockPXE();
+    context = createMockContext(mockWallet, mockPXE);
+    handlers = createContractHandlers();
+  });
+
+  describe('aztec_registerContract', () => {
+    it('should register contract with instance only', async () => {
+      const instance = {
+        address: '0x1234567890abcdef' as unknown as AztecAddress,
+        version: 1,
+        salt: new Fr(42n),
+        deployer: '0xabcdef1234567890' as unknown as AztecAddress,
+        contractClassId: new Fr(123n),
+        initializationHash: new Fr(456n),
+        publicKeysHash: new Fr(789n),
+      } as unknown as ContractInstanceWithAddress;
+
+      vi.mocked(mockWallet.registerContract).mockResolvedValue(undefined);
+
+      const result = await handlers.aztec_registerContract(context, [instance, undefined]);
+
+      expect(mockWallet.registerContract).toHaveBeenCalledWith({ instance });
+      expect(result).toBe(true);
+    });
+
+    it('should register contract with instance and artifact', async () => {
+      const instance = {
+        address: '0x1234567890abcdef' as unknown as AztecAddress,
+        version: 1,
+        salt: new Fr(42n),
+        deployer: '0xabcdef1234567890' as unknown as AztecAddress,
+        contractClassId: new Fr(123n),
+        initializationHash: new Fr(456n),
+        publicKeysHash: new Fr(789n),
+      } as unknown as ContractInstanceWithAddress;
+
+      const artifact = {
+        name: 'TestContract',
+        functions: [],
+        outputs: { structs: {}, globals: {} },
+        fileMap: {},
+        storageLayout: {},
+        notes: {},
+      } as unknown as ContractArtifact;
+
+      vi.mocked(mockWallet.registerContract).mockResolvedValue(undefined);
+
+      const result = await handlers.aztec_registerContract(context, [instance, artifact]);
+
+      expect(mockWallet.registerContract).toHaveBeenCalledWith({ instance, artifact });
+      expect(result).toBe(true);
+    });
+
+    it('should propagate errors from wallet.registerContract', async () => {
+      const instance = {
+        address: '0x1234567890abcdef' as unknown as AztecAddress,
+      } as unknown as ContractInstanceWithAddress;
+
+      const error = new Error('Failed to register contract');
+      vi.mocked(mockWallet.registerContract).mockRejectedValue(error);
+
+      await expect(handlers.aztec_registerContract(context, [instance, undefined])).rejects.toThrow(
+        'Failed to register contract',
+      );
+      expect(mockWallet.registerContract).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('aztec_registerContractClass', () => {
+    it('should register contract class with artifact', async () => {
+      const artifact = {
+        name: 'TestContract',
+        functions: [],
+        outputs: { structs: {}, globals: {} },
+        fileMap: {},
+        storageLayout: {},
+        notes: {},
+      } as unknown as ContractArtifact;
+
+      vi.mocked(mockWallet.registerContractClass).mockResolvedValue(undefined);
+
+      const result = await handlers.aztec_registerContractClass(context, [artifact]);
+
+      expect(mockWallet.registerContractClass).toHaveBeenCalledWith(artifact);
+      expect(result).toBe(true);
+    });
+
+    it('should propagate errors from wallet.registerContractClass', async () => {
+      const artifact = {
+        name: 'TestContract',
+      } as unknown as ContractArtifact;
+
+      const error = new Error('Failed to register contract class');
+      vi.mocked(mockWallet.registerContractClass).mockRejectedValue(error);
+
+      await expect(handlers.aztec_registerContractClass(context, [artifact])).rejects.toThrow(
+        'Failed to register contract class',
+      );
+      expect(mockWallet.registerContractClass).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('aztec_getContractMetadata', () => {
+    it('should get contract metadata for given address', async () => {
+      const address = '0x1234567890abcdef' as unknown as AztecAddress;
+      const expectedMetadata = {
+        name: 'TestContract',
+        portalContractAddress: '0xabc123' as unknown as AztecAddress,
+        blockNumber: 42,
+      } as unknown as ContractMetadata;
+
+      vi.mocked(mockWallet.getContractMetadata).mockResolvedValue(expectedMetadata);
+
+      const result = await handlers.aztec_getContractMetadata(context, [address]);
+
+      expect(mockWallet.getContractMetadata).toHaveBeenCalledWith(address);
+      expect(result).toBe(expectedMetadata);
+    });
+
+    it('should propagate errors from wallet.getContractMetadata', async () => {
+      const address = '0x1234567890abcdef' as unknown as AztecAddress;
+      const error = new Error('Contract not found');
+      vi.mocked(mockWallet.getContractMetadata).mockRejectedValue(error);
+
+      await expect(handlers.aztec_getContractMetadata(context, [address])).rejects.toThrow(
+        'Contract not found',
+      );
+      expect(mockWallet.getContractMetadata).toHaveBeenCalledWith(address);
+    });
+  });
+
+  describe('aztec_getContracts', () => {
+    it('should get all contracts from PXE', async () => {
+      const expectedContracts = [
+        '0x1234567890abcdef' as unknown as AztecAddress,
+        '0xabcdef1234567890' as unknown as AztecAddress,
+      ];
+
+      vi.mocked(mockPXE.getContracts).mockResolvedValue(expectedContracts);
+
+      const result = await handlers.aztec_getContracts(context, []);
+
+      expect(mockPXE.getContracts).toHaveBeenCalledOnce();
+      expect(result).toBe(expectedContracts);
+    });
+
+    it('should propagate errors from pxe.getContracts', async () => {
+      const error = new Error('Failed to get contracts');
+      vi.mocked(mockPXE.getContracts).mockRejectedValue(error);
+
+      await expect(handlers.aztec_getContracts(context, [])).rejects.toThrow('Failed to get contracts');
+      expect(mockPXE.getContracts).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('aztec_getContractClassMetadata', () => {
+    it('should get contract class metadata without artifact', async () => {
+      const id = new Fr(123n);
+      const expectedMetadata = {
+        id,
+        artifactHash: new Fr(456n),
+        privateFunctionsRoot: new Fr(789n),
+        packedBytecode: Buffer.from('bytecode'),
+      } as unknown as ContractClassMetadata;
+
+      vi.mocked(mockWallet.getContractClassMetadata).mockResolvedValue(expectedMetadata);
+
+      const result = await handlers.aztec_getContractClassMetadata(context, [id, undefined]);
+
+      expect(mockWallet.getContractClassMetadata).toHaveBeenCalledWith(id, false);
+      expect(result).toBe(expectedMetadata);
+    });
+
+    it('should get contract class metadata with artifact', async () => {
+      const id = new Fr(123n);
+      const includeArtifact = true;
+      const expectedMetadata = {
+        id,
+        artifactHash: new Fr(456n),
+        privateFunctionsRoot: new Fr(789n),
+        packedBytecode: Buffer.from('bytecode'),
+        artifact: {
+          name: 'TestContract',
+          functions: [],
+        },
+      } as unknown as ContractClassMetadata;
+
+      vi.mocked(mockWallet.getContractClassMetadata).mockResolvedValue(expectedMetadata);
+
+      const result = await handlers.aztec_getContractClassMetadata(context, [id, includeArtifact]);
+
+      expect(mockWallet.getContractClassMetadata).toHaveBeenCalledWith(id, includeArtifact);
+      expect(result).toBe(expectedMetadata);
+    });
+
+    it('should propagate errors from wallet.getContractClassMetadata', async () => {
+      const id = new Fr(123n);
+      const error = new Error('Contract class not found');
+      vi.mocked(mockWallet.getContractClassMetadata).mockRejectedValue(error);
+
+      await expect(handlers.aztec_getContractClassMetadata(context, [id, undefined])).rejects.toThrow(
+        'Contract class not found',
+      );
+      expect(mockWallet.getContractClassMetadata).toHaveBeenCalledWith(id, false);
+    });
+  });
+});

package/src/wallet/handlers/contract.ts

@@ -0,0 +1,174 @@
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { AztecWalletMethodMap } from '../../types.js';
+import type { AztecHandlerContext } from './index.js';
+import { createLogger } from '@aztec/foundation/log';
+
+const logger = createLogger('aztec-rpc-wallet:contract');
+
+/**
+ * Creates handlers for contract-related Aztec wallet JSON-RPC methods.
+ * These handlers are responsible for managing the registration of deployed contract
+ * instances and contract classes (artifacts), as well as retrieving contract metadata.
+ *
+ * Each handler function receives an {@link AztecHandlerContext} which provides access
+ * to the {@link AccountWallet}, {@link PXE} client, and {@link ContractArtifactCache}.
+ *
+ * @returns An object where keys are contract-related method names
+ *          (e.g., "aztec_registerContract", "aztec_getContractMetadata") and values
+ *          are their corresponding handler functions.
+ * @see {@link AztecWalletMethodMap} for method definitions.
+ */
+export function createContractHandlers() {
+  return {
+    /**
+     * Handles the "aztec_registerContract" JSON-RPC method.
+     * Registers a deployed contract instance with the {@link AccountWallet} in the context.
+     * This allows the wallet to be aware of and interact with the specified contract.
+     * An optional {@link ContractArtifact} can be provided to include ABI information.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the contract instance and optional artifact.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_registerContract.params}.
+     * @param paramsTuple.0 - The {@link ContractInstanceWithAddress} to register.
+     * @param paramsTuple.1 - Optional: The {@link ContractArtifact} associated with the instance.
+     * @returns A promise that resolves to `true` if the registration was successful.
+     * @throws {Error} If critical parameters like `instance` are missing or invalid,
+     *                 though type checking and serializer validation should catch this earlier.
+     */
+    aztec_registerContract: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_registerContract']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_registerContract']['result']> => {
+      const [instance, artifact] = paramsTuple;
+      logger.debug(
+        `[HANDLER] aztec_registerContract: instance = ${instance?.address?.toString()}, artifact provided = ${!!artifact}`,
+      );
+      // Original logic used `instance === undefined` check, but instance is not optional in the tuple.
+      // The type system should ensure `instance` is provided.
+      // If `instance` itself could be undefined in the tuple, the tuple type would be `[ContractInstanceWithAddress | undefined, ...]`.
+      // Assuming `instance` is guaranteed by the tuple type.
+      const contractToRegister: { instance: ContractInstanceWithAddress; artifact?: ContractArtifact } = {
+        instance,
+      };
+      if (artifact) {
+        contractToRegister.artifact = artifact;
+      }
+      await ctx.wallet.registerContract(contractToRegister);
+      return true;
+    },
+
+    /**
+     * Handles the "aztec_registerContractClass" JSON-RPC method.
+     * Registers a contract class (defined by its {@link ContractArtifact}) with the
+     * {@link AccountWallet} in the context. This makes the contract's bytecode and ABI
+     * known to the wallet, typically for future deployments or interactions.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the contract artifact.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_registerContractClass.params}.
+     * @param paramsTuple.0 - The {@link ContractArtifact} to register.
+     * @returns A promise that resolves to `true` if the registration was successful.
+     * @throws {Error} If the `artifact` parameter is missing or invalid,
+     *                 though type checking and serializer validation should catch this earlier.
+     */
+    aztec_registerContractClass: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_registerContractClass']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_registerContractClass']['result']> => {
+      const [artifact] = paramsTuple;
+      logger.debug(`[HANDLER] aztec_registerContractClass: artifact name = ${artifact?.name}`);
+      // Artifact is not optional in the tuple type.
+      await ctx.wallet.registerContractClass(artifact);
+      return true;
+    },
+
+    /**
+     * Handles the "aztec_getContractMetadata" JSON-RPC method.
+     * Retrieves {@link ContractMetadata} for a deployed contract at a given {@link AztecAddress},
+     * using the {@link AccountWallet} in the context.
+     *
+     * Contract metadata typically includes information about the contract's instance,
+     * initialization status, and public deployment status.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the contract address.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_getContractMetadata.params}.
+     * @param paramsTuple.0 - The {@link AztecAddress} of the contract.
+     * @returns A promise that resolves to the {@link ContractMetadata}.
+     * @throws {Error} If the `address` parameter is missing or invalid, or if metadata is not found.
+     */
+    aztec_getContractMetadata: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_getContractMetadata']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_getContractMetadata']['result']> => {
+      const [address] = paramsTuple;
+      logger.debug(`[HANDLER] aztec_getContractMetadata: address = ${address?.toString()}`);
+      // Address is not optional in the tuple type.
+      // Add runtime check for robustness if needed, though TS should catch it.
+      if (!address || typeof address.toString !== 'function') {
+        // Basic check
+        throw new Error('Invalid address parameter received in tuple');
+      }
+      const metadata = await ctx.wallet.getContractMetadata(address);
+      if (!metadata) {
+        throw new Error(`Contract metadata not found for address: ${address.toString()}`);
+      }
+      return metadata;
+    },
+
+    /**
+     * Handles the "aztec_getContracts" JSON-RPC method.
+     * Retrieves a list of {@link AztecAddress}es for all contracts known to the {@link PXE}
+     * instance in the current context. This typically includes contracts that have been
+     * registered or deployed through this PXE.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `pxe` instance.
+     * @param _paramsTuple - Parameters for this method (expected to be an empty array).
+     *                       Defined by {@link AztecWalletMethodMap.aztec_getContracts.params}.
+     * @returns A promise that resolves to an array of {@link AztecAddress} objects.
+     *          Type defined by {@link AztecWalletMethodMap.aztec_getContracts.result}.
+     */
+    aztec_getContracts: async (
+      ctx: AztecHandlerContext,
+      _paramsTuple: AztecWalletMethodMap['aztec_getContracts']['params'], // Will be `[]`
+    ): Promise<AztecWalletMethodMap['aztec_getContracts']['result']> => {
+      logger.debug('[HANDLER] aztec_getContracts');
+      return await ctx.pxe.getContracts();
+    },
+
+    /**
+     * Handles the "aztec_getContractClassMetadata" JSON-RPC method.
+     * Retrieves {@link ContractClassMetadata} for a contract class identified by its {@link Fr} ID,
+     * using the {@link AccountWallet} in the context.
+     *
+     * Contract class metadata provides information about a registered contract class,
+     * potentially including its artifact if requested.
+     *
+     * @param ctx - The {@link AztecHandlerContext} containing the `wallet` instance.
+     * @param paramsTuple - A tuple containing the class ID and an optional flag to include the artifact.
+     *                      Defined by {@link AztecWalletMethodMap.aztec_getContractClassMetadata.params}.
+     * @param paramsTuple.0 - The {@link Fr} ID of the contract class.
+     * @param paramsTuple.1 - Optional: A boolean indicating whether to include the full {@link ContractArtifact}
+     *                        in the returned metadata. Defaults to `false`.
+     * @returns A promise that resolves to the {@link ContractClassMetadata}.
+     * @throws {Error} If the `id` parameter is missing or invalid.
+     */
+    aztec_getContractClassMetadata: async (
+      ctx: AztecHandlerContext,
+      paramsTuple: AztecWalletMethodMap['aztec_getContractClassMetadata']['params'],
+    ): Promise<AztecWalletMethodMap['aztec_getContractClassMetadata']['result']> => {
+      const [id, includeArtifactInput] = paramsTuple;
+      const includeArtifact = includeArtifactInput === undefined ? false : includeArtifactInput; // Default for optional
+      logger.debug(
+        `[HANDLER] aztec_getContractClassMetadata: id = ${id?.toString()}, includeArtifact = ${includeArtifact}`,
+      );
+      // Id is not optional in the tuple type.
+      if (!id || typeof id.toString !== 'function') {
+        // Basic check for Fr-like object
+        throw new Error('Invalid id parameter received in tuple');
+      }
+      return await ctx.wallet.getContractClassMetadata(id, includeArtifact);
+    },
+  };
+}

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

@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createEventHandlers } from './event.js';
+import type { AccountWallet, PXE, AztecAddress } from '@aztec/aztec.js';
+import type { EventMetadataDefinition } from '@aztec/stdlib/interfaces/client';
+import type { AztecHandlerContext } from './index.js';
+import type { ContractArtifactCache } from '../../contractArtifactCache.js';
+
+// Mock dependencies
+const createMockWallet = () =>
+  ({
+    // No specific methods needed for event handlers
+  }) as unknown as AccountWallet;
+
+const createMockPXE = () =>
+  ({
+    getPrivateEvents: vi.fn(),
+    getPublicEvents: vi.fn(),
+  }) as unknown as PXE;
+
+const createMockContext = (wallet: AccountWallet, pxe: PXE): AztecHandlerContext => ({
+  wallet,
+  pxe,
+  cache: {} as ContractArtifactCache,
+});
+
+describe('Event Handlers', () => {
+  let mockWallet: AccountWallet;
+  let mockPXE: PXE;
+  let context: AztecHandlerContext;
+  let handlers: ReturnType<typeof createEventHandlers>;
+
+  beforeEach(() => {
+    mockWallet = createMockWallet();
+    mockPXE = createMockPXE();
+    context = createMockContext(mockWallet, mockPXE);
+    handlers = createEventHandlers();
+  });
+
+  describe('aztec_getPrivateEvents', () => {
+    it('should get private events with all parameters', async () => {
+      const contractAddress = '0x1234567890abcdef' as unknown as AztecAddress;
+      const eventMetadata = {
+        eventSelector: 'TestEvent',
+        fieldNames: ['field1', 'field2'],
+      } as unknown as EventMetadataDefinition;
+      const from = 100;
+      const numBlocks = 50;
+      const recipients = [
+        '0xabcdef1234567890' as unknown as AztecAddress,
+        '0x567890abcdef1234' as unknown as AztecAddress,
+      ];
+
+      const expectedEvents = [
+        { eventType: 'TestEvent', data: { field1: 'value1', field2: 'value2' } },
+        { eventType: 'TestEvent', data: { field1: 'value3', field2: 'value4' } },
+      ];
+
+      vi.mocked(mockPXE.getPrivateEvents).mockResolvedValue(expectedEvents);
+
+      const result = await handlers.aztec_getPrivateEvents(context, [
+        contractAddress,
+        eventMetadata,
+        from,
+        numBlocks,
+        recipients,
+      ]);
+
+      expect(mockPXE.getPrivateEvents).toHaveBeenCalledWith(
+        contractAddress,
+        eventMetadata,
+        from,
+        numBlocks,
+        recipients,
+      );
+      expect(result).toBe(expectedEvents);
+    });
+
+    it('should get private events with minimal parameters', async () => {
+      const contractAddress = '0x1234567890abcdef' as unknown as AztecAddress;
+      const eventMetadata = {
+        eventSelector: 'TestEvent',
+        fieldNames: ['field1'],
+      } as unknown as EventMetadataDefinition;
+      const from = 0;
+      const numBlocks = 10;
+      const recipients: AztecAddress[] = [];
+
+      const expectedEvents = [{ eventType: 'TestEvent', data: { field1: 'value1' } }];
+
+      vi.mocked(mockPXE.getPrivateEvents).mockResolvedValue(expectedEvents);
+
+      const result = await handlers.aztec_getPrivateEvents(context, [
+        contractAddress,
+        eventMetadata,
+        from,
+        numBlocks,
+        recipients,
+      ]);
+
+      expect(mockPXE.getPrivateEvents).toHaveBeenCalledWith(
+        contractAddress,
+        eventMetadata,
+        from,
+        numBlocks,
+        recipients,
+      );
+      expect(result).toBe(expectedEvents);
+    });
+
+    it('should propagate errors from pxe.getPrivateEvents', async () => {
+      const contractAddress = '0x1234567890abcdef' as unknown as AztecAddress;
+      const eventMetadata = {
+        eventSelector: 'TestEvent',
+        fieldNames: ['field1'],
+      } as unknown as EventMetadataDefinition;
+      const from = 100;
+      const numBlocks = 50;
+      const recipients: AztecAddress[] = [];
+
+      const error = new Error('Failed to get private events');
+      vi.mocked(mockPXE.getPrivateEvents).mockRejectedValue(error);
+
+      await expect(
+        handlers.aztec_getPrivateEvents(context, [
+          contractAddress,
+          eventMetadata,
+          from,
+          numBlocks,
+          recipients,
+        ]),
+      ).rejects.toThrow('Failed to get private events');
+      expect(mockPXE.getPrivateEvents).toHaveBeenCalledWith(
+        contractAddress,
+        eventMetadata,
+        from,
+        numBlocks,
+        recipients,
+      );
+    });
+
+    it('should handle missing required parameters', async () => {
+      await expect(
+        handlers.aztec_getPrivateEvents(context, ['0x1234567890abcdef' as unknown as AztecAddress] as never),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('aztec_getPublicEvents', () => {
+    it('should get public events with all parameters', async () => {
+      const eventMetadata = {
+        eventSelector: 'PublicTestEvent',
+        fieldNames: ['publicField1', 'publicField2'],
+      } as unknown as EventMetadataDefinition;
+      const from = 200;
+      const limit = 25;
+
+      const expectedEvents = [
+        { eventType: 'PublicTestEvent', data: { publicField1: 'pubValue1', publicField2: 'pubValue2' } },
+        { eventType: 'PublicTestEvent', data: { publicField1: 'pubValue3', publicField2: 'pubValue4' } },
+      ];
+
+      vi.mocked(mockPXE.getPublicEvents).mockResolvedValue(expectedEvents);
+
+      const result = await handlers.aztec_getPublicEvents(context, [eventMetadata, from, limit]);
+
+      expect(mockPXE.getPublicEvents).toHaveBeenCalledWith(eventMetadata, from, limit);
+      expect(result).toBe(expectedEvents);
+    });
+
+    it('should get public events with minimal parameters', async () => {
+      const eventMetadata = {
+        eventSelector: 'PublicTestEvent',
+        fieldNames: ['publicField1'],
+      } as unknown as EventMetadataDefinition;
+      const from = 0;
+      const limit = 100;
+
+      const expectedEvents = [{ eventType: 'PublicTestEvent', data: { publicField1: 'pubValue1' } }];
+
+      vi.mocked(mockPXE.getPublicEvents).mockResolvedValue(expectedEvents);
+
+      const result = await handlers.aztec_getPublicEvents(context, [eventMetadata, from, limit]);
+
+      expect(mockPXE.getPublicEvents).toHaveBeenCalledWith(eventMetadata, from, limit);
+      expect(result).toBe(expectedEvents);
+    });
+
+    it('should propagate errors from pxe.getPublicEvents', async () => {
+      const eventMetadata = {
+        eventSelector: 'PublicTestEvent',
+        fieldNames: ['publicField1'],
+      } as unknown as EventMetadataDefinition;
+      const from = 200;
+      const limit = 25;
+
+      const error = new Error('Failed to get public events');
+      vi.mocked(mockPXE.getPublicEvents).mockRejectedValue(error);
+
+      await expect(handlers.aztec_getPublicEvents(context, [eventMetadata, from, limit])).rejects.toThrow(
+        'Failed to get public events',
+      );
+      expect(mockPXE.getPublicEvents).toHaveBeenCalledWith(eventMetadata, from, limit);
+    });
+
+    it('should handle missing required parameters', async () => {
+      await expect(
+        handlers.aztec_getPublicEvents(context, [
+          {
+            eventSelector: 'PublicTestEvent',
+            fieldNames: ['publicField1'],
+          } as unknown as EventMetadataDefinition,
+        ] as never),
+      ).rejects.toThrow();
+    });
+  });
+});