@walletmesh/aztec-rpc-wallet 0.3.0 → 0.4.0

package/src/serializers/log.test.ts

@@ -1,286 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Point, AztecAddress } from '@aztec/aztec.js';
-import { EventSelector } from '@aztec/foundation/abi';
-import type { AbiType } from '@aztec/foundation/abi';
-import {
-  ExtendedPublicLog,
-  type GetPublicLogsResponse,
-  type GetContractClassLogsResponse,
-  type LogFilter,
-  LogId,
-  TxHash,
-} from '@aztec/circuit-types';
-import {
-  aztecGetPublicLogsSerializer,
-  aztecGetPrivateEventsSerializer,
-  aztecGetPublicEventsSerializer,
-  aztecGetContractClassLogsSerializer,
-} from './log.js';
-
-describe('Log Serializers', () => {
-  describe('aztec_getPublicLogs', () => {
-    const METHOD = 'aztec_getPublicLogs';
-
-    it('should serialize and deserialize params', async () => {
-      const filter: LogFilter = {
-        txHash: await TxHash.random(),
-        fromBlock: 0,
-        toBlock: 100,
-        afterLog: await LogId.random(),
-        contractAddress: await AztecAddress.random(),
-      };
-
-      const params = { filter };
-
-      const serialized = await aztecGetPublicLogsSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPublicLogsSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.filter.contractAddress?.toString()).toBe(filter.contractAddress?.toString());
-      expect(deserialized.filter.txHash?.toString()).toBe(filter.txHash?.toString());
-      expect(deserialized.filter.fromBlock).toBe(filter.fromBlock);
-      expect(deserialized.filter.toBlock).toBe(filter.toBlock);
-      expect(deserialized.filter.afterLog?.toString()).toBe(filter.afterLog?.toString());
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const log = await ExtendedPublicLog.random();
-      const result: GetPublicLogsResponse = {
-        logs: [log],
-        maxLogsHit: false,
-      };
-
-      const serialized = await aztecGetPublicLogsSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPublicLogsSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized.logs.length).toBeGreaterThan(0);
-      // biome-ignore lint/style/noNonNullAssertion: We know this should be defined
-      expect(deserialized.logs[0]!.toString()).toBe(result.logs[0]!.toString());
-      expect(deserialized.logs.length).toBe(result.logs.length);
-      expect(deserialized.maxLogsHit).toBe(result.maxLogsHit);
-    });
-  });
-
-  describe('aztec_getPrivateEvents', () => {
-    const METHOD = 'aztec_getPrivateEvents';
-
-    it('should serialize and deserialize params', async () => {
-      const event = {
-        eventSelector: EventSelector.fromString('0x12345678'),
-        abiType: {
-          kind: 'field',
-        } as AbiType,
-        fieldNames: ['field1', 'field2'],
-      };
-      const params = {
-        event,
-        from: 0,
-        limit: 10,
-        vpks: [await Point.random(), await Point.random()],
-      };
-
-      const serialized = await aztecGetPrivateEventsSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPrivateEventsSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.event.eventSelector.toString()).toBe(event.eventSelector.toString());
-      expect(deserialized.event.abiType).toEqual(event.abiType);
-      expect(deserialized.event.fieldNames).toEqual(event.fieldNames);
-      expect(deserialized.from).toBe(params.from);
-      expect(deserialized.limit).toBe(params.limit);
-      expect(deserialized.vpks?.map((p) => p.toString())).toEqual(params.vpks.map((p) => p.toString()));
-    });
-  });
-
-  describe('aztec_getPublicEvents', () => {
-    const METHOD = 'aztec_getPublicEvents';
-
-    it('should serialize and deserialize params', async () => {
-      const event = {
-        eventSelector: EventSelector.fromString('0x12345678'),
-        abiType: {
-          kind: 'field',
-        } as AbiType,
-        fieldNames: ['field1', 'field2'],
-      };
-      const params = {
-        event,
-        from: 0,
-        limit: 10,
-      };
-
-      const serialized = await aztecGetPublicEventsSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPublicEventsSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.event.eventSelector.toString()).toBe(event.eventSelector.toString());
-      expect(deserialized.event.abiType).toEqual(event.abiType);
-      expect(deserialized.event.fieldNames).toEqual(event.fieldNames);
-      expect(deserialized.from).toBe(params.from);
-      expect(deserialized.limit).toBe(params.limit);
-    });
-  });
-
-  describe('aztec_getContractClassLogs', () => {
-    const METHOD = 'aztec_getContractClassLogs';
-
-    it('should serialize and deserialize params with complete filter', async () => {
-      const txHash = await TxHash.random();
-      const contractAddress = await AztecAddress.random();
-      const afterLog = await LogId.random();
-
-      const filter: LogFilter = {
-        txHash,
-        fromBlock: 0,
-        toBlock: 100,
-        afterLog,
-        contractAddress,
-      };
-
-      const params = { filter };
-      const serialized = await aztecGetContractClassLogsSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetContractClassLogsSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.filter.contractAddress?.toString()).toBe(filter.contractAddress?.toString());
-      expect(deserialized.filter.txHash?.toString()).toBe(filter.txHash?.toString());
-      expect(deserialized.filter.fromBlock).toBe(filter.fromBlock);
-      expect(deserialized.filter.toBlock).toBe(filter.toBlock);
-      expect(deserialized.filter.afterLog?.toString()).toBe(filter.afterLog?.toString());
-    });
-
-    it('should serialize and deserialize params with minimal filter', async () => {
-      const filter: LogFilter = {
-        fromBlock: 0,
-        toBlock: 100,
-      };
-
-      const params = { filter };
-      const serialized = await aztecGetContractClassLogsSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetContractClassLogsSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.filter.contractAddress).toBeUndefined();
-      expect(deserialized.filter.txHash).toBeUndefined();
-      expect(deserialized.filter.fromBlock).toBe(filter.fromBlock);
-      expect(deserialized.filter.toBlock).toBe(filter.toBlock);
-      expect(deserialized.filter.afterLog).toBeUndefined();
-    });
-
-    it('should serialize and deserialize result', async () => {
-      // Create a mock response that matches the schema
-      const result: GetContractClassLogsResponse = {
-        logs: [],
-        maxLogsHit: false,
-      };
-
-      const serialized = await aztecGetContractClassLogsSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetContractClassLogsSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized.logs).toEqual([]);
-      expect(deserialized.maxLogsHit).toBe(result.maxLogsHit);
-    });
-  });
-
-  describe('aztec_getPrivateEvents result handling', () => {
-    const METHOD = 'aztec_getPrivateEvents';
-
-    it('should serialize and deserialize empty result array', async () => {
-      const result: unknown[] = [];
-      const serialized = await aztecGetPrivateEventsSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPrivateEventsSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized).toEqual([]);
-    });
-
-    it('should serialize and deserialize result with multiple events', async () => {
-      const result = [
-        { id: 1, data: 'event1' },
-        { id: 2, data: 'event2' },
-        { id: 3, data: 'event3' },
-      ];
-
-      const serialized = await aztecGetPrivateEventsSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPrivateEventsSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized).toEqual(result);
-    });
-  });
-
-  describe('aztec_getPublicEvents result handling', () => {
-    const METHOD = 'aztec_getPublicEvents';
-
-    it('should serialize and deserialize empty result array', async () => {
-      const result: unknown[] = [];
-      const serialized = await aztecGetPublicEventsSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPublicEventsSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized).toEqual([]);
-    });
-
-    it('should serialize and deserialize result with multiple events', async () => {
-      const result = [
-        { id: 1, data: 'event1' },
-        { id: 2, data: 'event2' },
-        { id: 3, data: 'event3' },
-      ];
-
-      const serialized = await aztecGetPublicEventsSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetPublicEventsSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized).toEqual(result);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle invalid JSON in deserialization', async () => {
-      const METHOD = 'aztec_getPublicLogs';
-      const invalidData = { method: METHOD, serialized: 'invalid json' };
-
-      await expect(aztecGetPublicLogsSerializer.params.deserialize(METHOD, invalidData)).rejects.toThrow();
-    });
-
-    it('should handle malformed event selector', async () => {
-      const METHOD = 'aztec_getPublicEvents';
-      const params = {
-        event: {
-          // Create an invalid event selector by extending a valid one
-          eventSelector: Object.create(EventSelector.fromString('0x12345678'), {
-            toString: {
-              value: () => {
-                throw new Error('Invalid selector');
-              },
-            },
-          }),
-          abiType: { kind: 'field' } as AbiType,
-          fieldNames: ['field1'],
-        },
-        from: 0,
-        limit: 10,
-      };
-
-      await expect(aztecGetPublicEventsSerializer.params.serialize(METHOD, params)).rejects.toThrow();
-    });
-
-    it('should handle optional filter fields', async () => {
-      const METHOD = 'aztec_getPublicLogs';
-      const filter: LogFilter = {
-        fromBlock: 0,
-        toBlock: 0,
-      };
-
-      const params = { filter };
-      const serialized = await aztecGetPublicLogsSerializer.params.serialize(METHOD, params);
-      const deserialized = await aztecGetPublicLogsSerializer.params.deserialize(METHOD, serialized);
-
-      expect(deserialized.filter.fromBlock).toBe(0);
-      expect(deserialized.filter.toBlock).toBe(0);
-    });
-  });
-});

package/src/serializers/log.ts

@@ -1,292 +0,0 @@
-import type { AztecWalletMethodMap } from '../types.js';
-import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import type { EventMetadataDefinition } from '@aztec/circuit-types';
-import {
-  GetPublicLogsResponseSchema,
-  GetContractClassLogsResponseSchema,
-  TxHash,
-  LogId,
-} from '@aztec/circuit-types';
-import { AztecAddress, type LogFilter, Point } from '@aztec/aztec.js';
-import { EventSelector } from '@aztec/foundation/abi';
-
-/**
- * Serializer for the aztec_getPublicLogs RPC method.
- * Handles serialization of public log queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetPublicLogsSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getPublicLogs']['params'],
-      AztecWalletMethodMap['aztec_getPublicLogs']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getPublicLogs']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { filter } = value;
-      // Convert all fields that need string conversion
-      const serializedFilter = {
-        ...filter,
-        txHash: filter.txHash?.toString(),
-        contractAddress: filter.contractAddress?.toString(),
-        afterLog: filter.afterLog?.toString(),
-        fromBlock: filter.fromBlock,
-        toBlock: filter.toBlock,
-      };
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify({ filter: serializedFilter }),
-      });
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getPublicLogs']['params']> => {
-      const { filter } = JSON.parse(data.serialized);
-      const deserializedFilter: Partial<{
-        txHash: TxHash;
-        contractAddress: AztecAddress;
-        afterLog: LogId;
-        fromBlock: number;
-        toBlock: number;
-      }> = {};
-
-      if (filter.txHash) deserializedFilter.txHash = TxHash.fromString(filter.txHash);
-      if (filter.contractAddress)
-        deserializedFilter.contractAddress = AztecAddress.fromString(filter.contractAddress);
-      if (filter.afterLog) deserializedFilter.afterLog = LogId.fromString(filter.afterLog);
-      if (filter.fromBlock !== undefined) deserializedFilter.fromBlock = filter.fromBlock;
-      if (filter.toBlock !== undefined) deserializedFilter.toBlock = filter.toBlock;
-
-      return Promise.resolve({ filter: deserializedFilter });
-    },
-  };
-
-  result = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getPublicLogs']['result'],
-    ): Promise<JSONRPCSerializedData> => {
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify(value),
-      });
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getPublicLogs']['result']> => {
-      return Promise.resolve(GetPublicLogsResponseSchema.parse(JSON.parse(data.serialized)));
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_getContractClassLogs RPC method.
- * Handles serialization of contract class log queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetContractClassLogsSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getContractClassLogs']['params'],
-      AztecWalletMethodMap['aztec_getContractClassLogs']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getContractClassLogs']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { filter } = value;
-      // Convert fields to strings for schema validation
-      const serializedFilter = {
-        txHash: filter.txHash?.toString() ?? undefined,
-        contractAddress: filter.contractAddress?.toString() ?? undefined,
-        afterLog: filter.afterLog?.toString() ?? undefined,
-        fromBlock: filter.fromBlock,
-        toBlock: filter.toBlock,
-      };
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify({ filter: serializedFilter }),
-      });
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getContractClassLogs']['params']> => {
-      const { filter } = JSON.parse(data.serialized);
-      const deserializedFilter: LogFilter = {};
-
-      if (filter.txHash) deserializedFilter.txHash = TxHash.fromString(filter.txHash);
-      if (filter.contractAddress)
-        deserializedFilter.contractAddress = AztecAddress.fromString(filter.contractAddress);
-      if (filter.afterLog) deserializedFilter.afterLog = LogId.fromString(filter.afterLog);
-      if (filter.fromBlock !== undefined) deserializedFilter.fromBlock = filter.fromBlock;
-      if (filter.toBlock !== undefined) deserializedFilter.toBlock = filter.toBlock;
-
-      return Promise.resolve({ filter: deserializedFilter });
-    },
-  };
-
-  result = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getContractClassLogs']['result'],
-    ): Promise<JSONRPCSerializedData> => {
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify(GetContractClassLogsResponseSchema.parse(value)),
-      });
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getContractClassLogs']['result']> => {
-      return Promise.resolve(GetContractClassLogsResponseSchema.parse(JSON.parse(data.serialized)));
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_getPrivateEvents RPC method.
- * Handles serialization of private event queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetPrivateEventsSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getPrivateEvents']['params'],
-      AztecWalletMethodMap['aztec_getPrivateEvents']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getPrivateEvents']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { event, from, limit, vpks } = value;
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify({
-          event: {
-            eventSelector: event.eventSelector.toString(),
-            abiType: {
-              kind: event.abiType.kind,
-            },
-            fieldNames: event.fieldNames,
-          },
-          from,
-          limit,
-          vpks: vpks?.map((p) => p.toString()),
-        }),
-      });
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getPrivateEvents']['params']> => {
-      const { event: serializedEvent, from, limit, vpks } = JSON.parse(data.serialized);
-      const event: EventMetadataDefinition = {
-        eventSelector: EventSelector.fromString(serializedEvent.eventSelector),
-        abiType: {
-          kind: serializedEvent.abiType.kind,
-        },
-        fieldNames: serializedEvent.fieldNames,
-      };
-      return Promise.resolve({
-        event,
-        from,
-        limit,
-        vpks: vpks?.map((p: string) => Point.fromString(p)),
-      });
-    },
-  };
-
-  result = {
-    serialize: async (method: string, value: unknown[]): Promise<JSONRPCSerializedData> => {
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify(value),
-      });
-    },
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<unknown[]> => {
-      return Promise.resolve(JSON.parse(data.serialized));
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_getPublicEvents RPC method.
- * Handles serialization of public event queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetPublicEventsSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getPublicEvents']['params'],
-      AztecWalletMethodMap['aztec_getPublicEvents']['result']
-    >
-{
-  params = {
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getPublicEvents']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { event, from, limit } = value;
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify({
-          event: {
-            eventSelector: event.eventSelector.toString(),
-            abiType: {
-              kind: event.abiType.kind,
-            },
-            fieldNames: event.fieldNames,
-          },
-          from,
-          limit,
-        }),
-      });
-    },
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getPublicEvents']['params']> => {
-      const { event: serializedEvent, from, limit } = JSON.parse(data.serialized);
-      const event: EventMetadataDefinition = {
-        eventSelector: EventSelector.fromString(serializedEvent.eventSelector),
-        abiType: {
-          kind: serializedEvent.abiType.kind,
-        },
-        fieldNames: serializedEvent.fieldNames,
-      };
-      return Promise.resolve({
-        event,
-        from,
-        limit,
-      });
-    },
-  };
-
-  result = {
-    serialize: async (method: string, value: unknown[]): Promise<JSONRPCSerializedData> => {
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify(value),
-      });
-    },
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<unknown[]> => {
-      return Promise.resolve(JSON.parse(data.serialized));
-    },
-  };
-}
-
-/**
- * Pre-instantiated serializer instances for each Aztec log/event-related RPC method.
- */
-export const aztecGetPublicLogsSerializer = new AztecGetPublicLogsSerializer();
-export const aztecGetContractClassLogsSerializer = new AztecGetContractClassLogsSerializer();
-export const aztecGetPrivateEventsSerializer = new AztecGetPrivateEventsSerializer();
-export const aztecGetPublicEventsSerializer = new AztecGetPublicEventsSerializer();

package/src/serializers/note.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Fr, AztecAddress, ExtendedNote } from '@aztec/aztec.js';
-import { type NotesFilter, NoteStatus, TxHash, UniqueNote } from '@aztec/circuit-types';
-import { aztecGetNotesSerializer, aztecAddNoteSerializer, aztecAddNullifiedNoteSerializer } from './note.js';
-
-describe('Note Serializers', () => {
-  describe('aztec_getNotes', () => {
-    const METHOD = 'aztec_getNotes';
-
-    it('should serialize and deserialize params', async () => {
-      const filter: NotesFilter = {
-        txHash: await TxHash.random(),
-        contractAddress: await AztecAddress.random(),
-        storageSlot: await Fr.random(),
-        owner: await AztecAddress.random(),
-        status: NoteStatus.ACTIVE,
-        siloedNullifier: await Fr.random(),
-        scopes: [await AztecAddress.random()],
-      };
-      const params = { filter };
-
-      const serialized = await aztecGetNotesSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetNotesSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.filter.txHash?.toString()).toBe(filter.txHash?.toString());
-      expect(deserialized.filter.contractAddress?.toString()).toBe(filter.contractAddress?.toString());
-      expect(deserialized.filter.storageSlot?.toString()).toBe(filter.storageSlot?.toString());
-      expect(deserialized.filter.owner?.toString()).toBe(filter.owner?.toString());
-      expect(deserialized.filter.status).toBe(filter.status);
-      expect(deserialized.filter.siloedNullifier?.toString()).toBe(filter.siloedNullifier?.toString());
-      expect(deserialized.filter.scopes?.map((s) => s.toString())).toEqual(
-        filter.scopes?.map((s) => s.toString()),
-      );
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const result = [await UniqueNote.random(), await UniqueNote.random()];
-
-      const serialized = await aztecGetNotesSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetNotesSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized.map((note: UniqueNote) => note.toString())).toEqual(
-        result.map((note: UniqueNote) => note.toString()),
-      );
-    });
-  });
-
-  describe('aztec_addNote', () => {
-    const METHOD = 'aztec_addNote';
-
-    it('should serialize and deserialize params', async () => {
-      const note = await ExtendedNote.random();
-      const params = { note };
-
-      const serialized = await aztecAddNoteSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecAddNoteSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.note.toBuffer().toString('hex')).toBe(note.toBuffer().toString('hex'));
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const result = true;
-
-      const serialized = await aztecAddNoteSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecAddNoteSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized).toBe(result);
-    });
-  });
-
-  describe('aztec_addNullifiedNote', () => {
-    const METHOD = 'aztec_addNullifiedNote';
-
-    it('should serialize and deserialize params', async () => {
-      const note = await ExtendedNote.random();
-      const params = { note };
-
-      const serialized = await aztecAddNullifiedNoteSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecAddNullifiedNoteSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.note.toBuffer().toString('hex')).toBe(note.toBuffer().toString('hex'));
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const result = true;
-
-      const serialized = await aztecAddNullifiedNoteSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecAddNullifiedNoteSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized).toBe(result);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle invalid JSON in deserialization', async () => {
-      const METHOD = 'aztec_getNotes';
-      const invalidData = { method: METHOD, serialized: 'invalid json' };
-
-      await expect(aztecGetNotesSerializer.params.deserialize(METHOD, invalidData)).rejects.toThrow();
-    });
-
-    it('should handle empty filter fields', async () => {
-      const METHOD = 'aztec_getNotes';
-      const filter: NotesFilter = {};
-      const params = { filter };
-
-      const serialized = await aztecGetNotesSerializer.params.serialize(METHOD, params);
-      const deserialized = await aztecGetNotesSerializer.params.deserialize(METHOD, serialized);
-
-      expect(deserialized.filter.txHash).toBeUndefined();
-      expect(deserialized.filter.contractAddress).toBeUndefined();
-      expect(deserialized.filter.storageSlot).toBeUndefined();
-      expect(deserialized.filter.owner).toBeUndefined();
-      expect(deserialized.filter.status).toBeUndefined();
-      expect(deserialized.filter.siloedNullifier).toBeUndefined();
-      expect(deserialized.filter.scopes).toBeUndefined();
-    });
-  });
-});