@walletmesh/aztec-rpc-wallet 0.1.0

package/src/serializers/log.ts

@@ -0,0 +1,283 @@
+import type { AztecWalletMethodMap } from '../types.js';
+import type { JSONRPCSerializedData, JSONRPCSerializer } from './types.js';
+import { encodeBase64, decodeBase64 } from './types.js';
+import type { EventMetadataDefinition } from '@aztec/circuit-types';
+import { ExtendedUnencryptedL2Log, TxHash, LogId } from '@aztec/circuit-types';
+import { Point, AztecAddress } from '@aztec/aztec.js';
+import { EventSelector, AbiTypeSchema } from '@aztec/foundation/abi';
+import type { LogFilter } from '@aztec/aztec.js';
+
+/**
+ * Serializer for the aztec_getUnencryptedLogs RPC method.
+ * Handles serialization of unencrypted log queries and results between JSON-RPC format and native Aztec types.
+ * Supports filtering logs by transaction hash, block range, and contract address.
+ */
+export class AztecGetUnencryptedLogsSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getUnencryptedLogs']['params'],
+      AztecWalletMethodMap['aztec_getUnencryptedLogs']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes log filter parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The filter parameters including txHash, block range, and contract address
+     * @returns Serialized filter data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getUnencryptedLogs']['params'],
+    ): JSONRPCSerializedData => {
+      const { filter } = value;
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify({
+            txHash: filter.txHash?.toString(),
+            fromBlock: filter.fromBlock,
+            toBlock: filter.toBlock,
+            afterLog: filter.afterLog?.toString(),
+            contractAddress: filter.contractAddress?.toString(),
+          }),
+        ),
+      };
+    },
+    /**
+     * Deserializes log filter parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized filter data
+     * @returns Deserialized filter parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getUnencryptedLogs']['params'] => {
+      const parsed = JSON.parse(decodeBase64(data.serialized));
+      const filter: LogFilter = {
+        txHash: parsed.txHash ? TxHash.fromString(parsed.txHash) : undefined,
+        fromBlock: parsed.fromBlock,
+        toBlock: parsed.toBlock,
+        afterLog: parsed.afterLog ? LogId.fromString(parsed.afterLog) : undefined,
+        contractAddress: parsed.contractAddress ? AztecAddress.fromString(parsed.contractAddress) : undefined,
+      };
+      return { filter };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes unencrypted log results for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The log results including logs array and maxLogsHit flag
+     * @returns Serialized log data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getUnencryptedLogs']['result'],
+    ): JSONRPCSerializedData => {
+      const serializedLogs = value.logs.map((log) => log.toString());
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify({ serializedLogs, maxLogsHit: value.maxLogsHit })),
+      };
+    },
+    /**
+     * Deserializes unencrypted log results from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized log data
+     * @returns Deserialized log results
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getUnencryptedLogs']['result'] => {
+      const { serializedLogs, maxLogsHit } = JSON.parse(decodeBase64(data.serialized));
+      return {
+        logs: serializedLogs.map((log: string) => ExtendedUnencryptedL2Log.fromString(log)),
+        maxLogsHit,
+      };
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_getEncryptedEvents RPC method.
+ * Handles serialization of encrypted event queries and results between JSON-RPC format and native Aztec types.
+ * Supports querying events with viewing keys for decryption.
+ */
+export class AztecGetEncryptedEventsSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getEncryptedEvents']['params'],
+      AztecWalletMethodMap['aztec_getEncryptedEvents']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes encrypted event query parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The query parameters including event metadata, range, and viewing keys
+     * @returns Serialized query data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getEncryptedEvents']['params'],
+    ): JSONRPCSerializedData => {
+      const { event, from, limit, vpks } = value;
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify({
+            event: {
+              eventSelector: event.eventSelector.toString(),
+              abiType: {
+                kind: event.abiType.kind,
+              },
+              fieldNames: event.fieldNames,
+            },
+            from,
+            limit,
+            vpks: vpks?.map((p) => p.toString()),
+          }),
+        ),
+      };
+    },
+    /**
+     * Deserializes encrypted event query parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized query data
+     * @returns Deserialized query parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getEncryptedEvents']['params'] => {
+      const { event: serializedEvent, from, limit, vpks } = JSON.parse(decodeBase64(data.serialized));
+      const event: EventMetadataDefinition = {
+        eventSelector: EventSelector.fromString(serializedEvent.eventSelector),
+        abiType: {
+          kind: serializedEvent.abiType.kind,
+        },
+        fieldNames: serializedEvent.fieldNames,
+      };
+      return {
+        event,
+        from,
+        limit,
+        vpks: vpks?.map((p: string) => Point.fromString(p)),
+      };
+    },
+  };
+
+  /**
+   * Handles serialization of encrypted event results.
+   * Note: The result type is generic (T[]) based on the event's ABI type definition.
+   * Currently handles results as unknown[] until proper ABI-based deserialization is implemented.
+   */
+  result = {
+    serialize: (method: string, value: unknown[]): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    deserialize: (method: string, data: JSONRPCSerializedData): unknown[] => {
+      return JSON.parse(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_getUnencryptedEvents RPC method.
+ * Handles serialization of unencrypted event queries and results between JSON-RPC format and native Aztec types.
+ * Supports querying events by event selector and pagination parameters.
+ */
+export class AztecGetUnencryptedEventsSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getUnencryptedEvents']['params'],
+      AztecWalletMethodMap['aztec_getUnencryptedEvents']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes unencrypted event query parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The query parameters including event metadata and range
+     * @returns Serialized query data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getUnencryptedEvents']['params'],
+    ): JSONRPCSerializedData => {
+      const { event, from, limit } = value;
+      return {
+        method,
+        serialized: encodeBase64(
+          JSON.stringify({
+            event: {
+              eventSelector: event.eventSelector.toString(),
+              abiType: {
+                kind: event.abiType.kind,
+              },
+              fieldNames: event.fieldNames,
+            },
+            from,
+            limit,
+          }),
+        ),
+      };
+    },
+    /**
+     * Deserializes unencrypted event query parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized query data
+     * @returns Deserialized query parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getUnencryptedEvents']['params'] => {
+      const { event: serializedEvent, from, limit } = JSON.parse(decodeBase64(data.serialized));
+      const event: EventMetadataDefinition = {
+        eventSelector: EventSelector.fromString(serializedEvent.eventSelector),
+        abiType: {
+          kind: serializedEvent.abiType.kind,
+        },
+        fieldNames: serializedEvent.fieldNames,
+      };
+      return {
+        event,
+        from,
+        limit,
+      };
+    },
+  };
+
+  /**
+   * Handles serialization of unencrypted event results.
+   * Note: The result type is generic (T[]) based on the event's ABI type definition.
+   * Currently handles results as unknown[] until proper ABI-based deserialization is implemented.
+   */
+  result = {
+    serialize: (method: string, value: unknown[]): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    deserialize: (method: string, data: JSONRPCSerializedData): unknown[] => {
+      return JSON.parse(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Pre-instantiated serializer instances for each Aztec log/event-related RPC method.
+ * These instances can be used directly by the RPC handler implementation.
+ */
+export const aztecGetUnencryptedLogsSerializer = new AztecGetUnencryptedLogsSerializer();
+export const aztecGetEncryptedEventsSerializer = new AztecGetEncryptedEventsSerializer();
+export const aztecGetUnencryptedEventsSerializer = new AztecGetUnencryptedEventsSerializer();

package/src/serializers/note.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import { Fr, AztecAddress, ExtendedNote } from '@aztec/aztec.js';
+import { type IncomingNotesFilter, NoteStatus, TxHash, UniqueNote } from '@aztec/circuit-types';
+import {
+  aztecGetIncomingNotesSerializer,
+  aztecAddNoteSerializer,
+  aztecAddNullifiedNoteSerializer,
+} from './note.js';
+
+describe('Note Serializers', () => {
+  describe('aztec_getIncomingNotes', () => {
+    const METHOD = 'aztec_getIncomingNotes';
+
+    it('should serialize and deserialize params', () => {
+      const filter: IncomingNotesFilter = {
+        txHash: TxHash.random(),
+        contractAddress: AztecAddress.random(),
+        storageSlot: Fr.random(),
+        owner: AztecAddress.random(),
+        status: NoteStatus.ACTIVE,
+        siloedNullifier: Fr.random(),
+        scopes: [AztecAddress.random()],
+      };
+      const params = { filter };
+      const serialized = aztecGetIncomingNotesSerializer.params.serialize(METHOD, params);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecGetIncomingNotesSerializer.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((a) => a.toString())).toEqual(
+        filter.scopes?.map((a) => a.toString()),
+      );
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = [UniqueNote.random(), UniqueNote.random()];
+
+      const serialized = aztecGetIncomingNotesSerializer.result.serialize(METHOD, result);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecGetIncomingNotesSerializer.result.deserialize(METHOD, serialized);
+      expect(deserialized.map((n) => n.toString())).toEqual(result.map((n) => n.toString()));
+    });
+  });
+
+  describe('aztec_addNote', () => {
+    const METHOD = 'aztec_addNote';
+
+    it('should serialize and deserialize params', () => {
+      const note = ExtendedNote.random();
+      const params = { note };
+
+      const serialized = aztecAddNoteSerializer.params.serialize(METHOD, params);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecAddNoteSerializer.params.deserialize(METHOD, serialized);
+      expect(deserialized.note.toBuffer().toString('hex')).toBe(note.toBuffer().toString('hex'));
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = true;
+
+      const serialized = aztecAddNoteSerializer.result.serialize(METHOD, result);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecAddNoteSerializer.result.deserialize(METHOD, serialized);
+      expect(deserialized).toBe(result);
+    });
+  });
+
+  describe('aztec_addNullifiedNote', () => {
+    const METHOD = 'aztec_addNullifiedNote';
+
+    it('should serialize and deserialize params', () => {
+      const note = ExtendedNote.random();
+      const params = { note };
+
+      const serialized = aztecAddNullifiedNoteSerializer.params.serialize(METHOD, params);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecAddNullifiedNoteSerializer.params.deserialize(METHOD, serialized);
+      expect(deserialized.note.toBuffer().toString('hex')).toBe(note.toBuffer().toString('hex'));
+    });
+
+    it('should serialize and deserialize result', () => {
+      const result = true;
+
+      const serialized = aztecAddNullifiedNoteSerializer.result.serialize(METHOD, result);
+      expect(serialized.method).toBe(METHOD);
+
+      const deserialized = aztecAddNullifiedNoteSerializer.result.deserialize(METHOD, serialized);
+      expect(deserialized).toBe(result);
+    });
+  });
+});

package/src/serializers/note.ts

@@ -0,0 +1,227 @@
+import type { AztecWalletMethodMap } from '../types.js';
+import type { JSONRPCSerializedData, JSONRPCSerializer } from './types.js';
+import { encodeBase64, decodeBase64 } from './types.js';
+import type { IncomingNotesFilter } from '@aztec/circuit-types';
+import { UniqueNote } from '@aztec/circuit-types';
+import { ExtendedNote } from '@aztec/aztec.js';
+
+/**
+ * Serializer for the aztec_getIncomingNotes RPC method.
+ * Handles serialization of incoming note queries and results between JSON-RPC format and native Aztec types.
+ * Used to retrieve notes that have been sent to an account but not yet processed.
+ */
+export class AztecGetIncomingNotesSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_getIncomingNotes']['params'],
+      AztecWalletMethodMap['aztec_getIncomingNotes']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes incoming notes filter parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing filter criteria for incoming notes
+     * @returns Serialized filter data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getIncomingNotes']['params'],
+    ): JSONRPCSerializedData => {
+      const { filter } = value;
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(filter)),
+      };
+    },
+    /**
+     * Deserializes incoming notes filter parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized filter data
+     * @returns Deserialized filter parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getIncomingNotes']['params'] => {
+      const filter = JSON.parse(decodeBase64(data.serialized)) as IncomingNotesFilter;
+      return { filter };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the incoming notes query result.
+     * @param method - The RPC method name
+     * @param value - Array of unique notes matching the filter criteria
+     * @returns Serialized note array
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_getIncomingNotes']['result'],
+    ): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value.map((n) => n.toString()))),
+      };
+    },
+    /**
+     * Deserializes the incoming notes query result.
+     * @param method - The RPC method name
+     * @param data - The serialized note array data
+     * @returns Array of deserialized unique notes
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_getIncomingNotes']['result'] => {
+      return JSON.parse(decodeBase64(data.serialized)).map((n: string) => UniqueNote.fromString(n));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_addNote RPC method.
+ * Handles serialization of note addition requests between JSON-RPC format and native Aztec types.
+ * Used to add new notes to an account's note tree.
+ */
+export class AztecAddNoteSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_addNote']['params'],
+      AztecWalletMethodMap['aztec_addNote']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes note addition parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing the note to add
+     * @returns Serialized note data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_addNote']['params'],
+    ): JSONRPCSerializedData => {
+      const { note } = value;
+      return {
+        method,
+        serialized: encodeBase64(note.toBuffer().toString('hex')),
+      };
+    },
+    /**
+     * Deserializes note addition parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized note data
+     * @returns Deserialized note parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_addNote']['params'] => {
+      const note = ExtendedNote.fromBuffer(Buffer.from(decodeBase64(data.serialized), 'hex'));
+      return { note };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the note addition result.
+     * @param method - The RPC method name
+     * @param value - Boolean indicating success of the note addition
+     * @returns Serialized result
+     */
+    serialize: (method: string, value: boolean): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    /**
+     * Deserializes the note addition result.
+     * @param method - The RPC method name
+     * @param data - The serialized result data
+     * @returns Boolean indicating success
+     */
+    deserialize: (method: string, data: JSONRPCSerializedData): boolean => {
+      return JSON.parse(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Serializer for the aztec_addNullifiedNote RPC method.
+ * Handles serialization of nullified note addition requests between JSON-RPC format and native Aztec types.
+ * Used to mark notes as spent/nullified in the note tree.
+ */
+export class AztecAddNullifiedNoteSerializer
+  implements
+    JSONRPCSerializer<
+      AztecWalletMethodMap['aztec_addNullifiedNote']['params'],
+      AztecWalletMethodMap['aztec_addNullifiedNote']['result']
+    >
+{
+  params = {
+    /**
+     * Serializes nullified note addition parameters for RPC transport.
+     * @param method - The RPC method name
+     * @param value - The parameters containing the nullified note to add
+     * @returns Serialized note data
+     */
+    serialize: (
+      method: string,
+      value: AztecWalletMethodMap['aztec_addNullifiedNote']['params'],
+    ): JSONRPCSerializedData => {
+      const { note } = value;
+      return {
+        method,
+        serialized: encodeBase64(note.toBuffer().toString('hex')),
+      };
+    },
+    /**
+     * Deserializes nullified note addition parameters from RPC transport.
+     * @param method - The RPC method name
+     * @param data - The serialized note data
+     * @returns Deserialized note parameters
+     */
+    deserialize: (
+      method: string,
+      data: JSONRPCSerializedData,
+    ): AztecWalletMethodMap['aztec_addNullifiedNote']['params'] => {
+      const note = ExtendedNote.fromBuffer(Buffer.from(decodeBase64(data.serialized), 'hex'));
+      return { note };
+    },
+  };
+
+  result = {
+    /**
+     * Serializes the nullified note addition result.
+     * @param method - The RPC method name
+     * @param value - Boolean indicating success of the nullified note addition
+     * @returns Serialized result
+     */
+    serialize: (method: string, value: boolean): JSONRPCSerializedData => {
+      return {
+        method,
+        serialized: encodeBase64(JSON.stringify(value)),
+      };
+    },
+    /**
+     * Deserializes the nullified note addition result.
+     * @param method - The RPC method name
+     * @param data - The serialized result data
+     * @returns Boolean indicating success
+     */
+    deserialize: (method: string, data: JSONRPCSerializedData): boolean => {
+      return JSON.parse(decodeBase64(data.serialized));
+    },
+  };
+}
+
+/**
+ * Pre-instantiated serializer instances for Aztec note-related RPC methods.
+ * These instances can be used directly by the RPC handler implementation.
+ */
+export const aztecGetIncomingNotesSerializer = new AztecGetIncomingNotesSerializer();
+export const aztecAddNoteSerializer = new AztecAddNoteSerializer();
+export const aztecAddNullifiedNoteSerializer = new AztecAddNullifiedNoteSerializer();