@walletmesh/aztec-rpc-wallet 0.1.1 → 0.3.0

package/src/serializers/log.ts

@@ -2,14 +2,12 @@ import type { AztecWalletMethodMap } from '../types.js';
 import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
 import type { EventMetadataDefinition } from '@aztec/circuit-types';
 import {
-  ExtendedPublicLog,
-  LogFilterSchema,
   GetPublicLogsResponseSchema,
   GetContractClassLogsResponseSchema,
   TxHash,
   LogId,
 } from '@aztec/circuit-types';
-import { Point, AztecAddress } from '@aztec/aztec.js';
+import { AztecAddress, type LogFilter, Point } from '@aztec/aztec.js';
 import { EventSelector } from '@aztec/foundation/abi';
 
 /**
@@ -24,10 +22,10 @@ export class AztecGetPublicLogsSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getPublicLogs']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { filter } = value;
       // Convert all fields that need string conversion
       const serializedFilter = {
@@ -38,45 +36,50 @@ export class AztecGetPublicLogsSerializer
         fromBlock: filter.fromBlock,
         toBlock: filter.toBlock,
       };
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({ filter: serializedFilter }),
-      };
+      });
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getPublicLogs']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_getPublicLogs']['params']> => {
       const { filter } = JSON.parse(data.serialized);
-      return {
-        filter: {
-          txHash: filter.txHash ? TxHash.fromString(filter.txHash) : undefined,
-          contractAddress: filter.contractAddress
-            ? AztecAddress.fromString(filter.contractAddress)
-            : undefined,
-          afterLog: filter.afterLog ? LogId.fromString(filter.afterLog) : undefined,
-          fromBlock: filter.fromBlock,
-          toBlock: filter.toBlock,
-        },
-      };
+      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: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getPublicLogs']['result'],
-    ): JSONRPCSerializedData => {
-      return {
+    ): Promise<JSONRPCSerializedData> => {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify(value),
-      };
+      });
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getPublicLogs']['result'] => {
-      return GetPublicLogsResponseSchema.parse(JSON.parse(data.serialized));
+    ): Promise<AztecWalletMethodMap['aztec_getPublicLogs']['result']> => {
+      return Promise.resolve(GetPublicLogsResponseSchema.parse(JSON.parse(data.serialized)));
     },
   };
 }
@@ -93,10 +96,10 @@ export class AztecGetContractClassLogsSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getContractClassLogs']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { filter } = value;
       // Convert fields to strings for schema validation
       const serializedFilter = {
@@ -106,45 +109,44 @@ export class AztecGetContractClassLogsSerializer
         fromBlock: filter.fromBlock,
         toBlock: filter.toBlock,
       };
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({ filter: serializedFilter }),
-      };
+      });
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractClassLogs']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_getContractClassLogs']['params']> => {
       const { filter } = JSON.parse(data.serialized);
-      return {
-        filter: {
-          txHash: filter.txHash ? TxHash.fromString(filter.txHash) : undefined,
-          contractAddress: filter.contractAddress
-            ? AztecAddress.fromString(filter.contractAddress)
-            : undefined,
-          afterLog: filter.afterLog ? LogId.fromString(filter.afterLog) : undefined,
-          fromBlock: filter.fromBlock,
-          toBlock: filter.toBlock,
-        },
-      };
+      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: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getContractClassLogs']['result'],
-    ): JSONRPCSerializedData => {
-      return {
+    ): Promise<JSONRPCSerializedData> => {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify(GetContractClassLogsResponseSchema.parse(value)),
-      };
+      });
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractClassLogs']['result'] => {
-      return GetContractClassLogsResponseSchema.parse(JSON.parse(data.serialized));
+    ): Promise<AztecWalletMethodMap['aztec_getContractClassLogs']['result']> => {
+      return Promise.resolve(GetContractClassLogsResponseSchema.parse(JSON.parse(data.serialized)));
     },
   };
 }
@@ -161,12 +163,12 @@ export class AztecGetPrivateEventsSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getPrivateEvents']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { event, from, limit, vpks } = value;
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({
           event: {
@@ -180,12 +182,12 @@ export class AztecGetPrivateEventsSerializer
           limit,
           vpks: vpks?.map((p) => p.toString()),
         }),
-      };
+      });
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getPrivateEvents']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_getPrivateEvents']['params']> => {
       const { event: serializedEvent, from, limit, vpks } = JSON.parse(data.serialized);
       const event: EventMetadataDefinition = {
         eventSelector: EventSelector.fromString(serializedEvent.eventSelector),
@@ -194,24 +196,24 @@ export class AztecGetPrivateEventsSerializer
         },
         fieldNames: serializedEvent.fieldNames,
       };
-      return {
+      return Promise.resolve({
         event,
         from,
         limit,
         vpks: vpks?.map((p: string) => Point.fromString(p)),
-      };
+      });
     },
   };
 
   result = {
-    serialize: (method: string, value: unknown[]): JSONRPCSerializedData => {
-      return {
+    serialize: async (method: string, value: unknown[]): Promise<JSONRPCSerializedData> => {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify(value),
-      };
+      });
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): unknown[] => {
-      return JSON.parse(data.serialized);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<unknown[]> => {
+      return Promise.resolve(JSON.parse(data.serialized));
     },
   };
 }
@@ -228,12 +230,12 @@ export class AztecGetPublicEventsSerializer
     >
 {
   params = {
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getPublicEvents']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { event, from, limit } = value;
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({
           event: {
@@ -246,12 +248,12 @@ export class AztecGetPublicEventsSerializer
           from,
           limit,
         }),
-      };
+      });
     },
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getPublicEvents']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_getPublicEvents']['params']> => {
       const { event: serializedEvent, from, limit } = JSON.parse(data.serialized);
       const event: EventMetadataDefinition = {
         eventSelector: EventSelector.fromString(serializedEvent.eventSelector),
@@ -260,23 +262,23 @@ export class AztecGetPublicEventsSerializer
         },
         fieldNames: serializedEvent.fieldNames,
       };
-      return {
+      return Promise.resolve({
         event,
         from,
         limit,
-      };
+      });
     },
   };
 
   result = {
-    serialize: (method: string, value: unknown[]): JSONRPCSerializedData => {
-      return {
+    serialize: async (method: string, value: unknown[]): Promise<JSONRPCSerializedData> => {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify(value),
-      };
+      });
     },
-    deserialize: (method: string, data: JSONRPCSerializedData): unknown[] => {
-      return JSON.parse(data.serialized);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<unknown[]> => {
+      return Promise.resolve(JSON.parse(data.serialized));
     },
   };
 }

package/src/serializers/note.test.ts

@@ -18,28 +18,29 @@ describe('Note Serializers', () => {
         scopes: [await AztecAddress.random()],
       };
       const params = { filter };
-      const serialized = aztecGetNotesSerializer.params.serialize(METHOD, params);
+
+      const serialized = await aztecGetNotesSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetNotesSerializer.params.deserialize(METHOD, serialized);
+      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((a) => a.toString())).toEqual(
-        filter.scopes?.map((a) => a.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 = aztecGetNotesSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecGetNotesSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetNotesSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetNotesSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized.map((note: UniqueNote) => note.toString())).toEqual(
         result.map((note: UniqueNote) => note.toString()),
       );
@@ -53,20 +54,20 @@ describe('Note Serializers', () => {
       const note = await ExtendedNote.random();
       const params = { note };
 
-      const serialized = aztecAddNoteSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecAddNoteSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecAddNoteSerializer.params.deserialize(METHOD, serialized);
+      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', () => {
+    it('should serialize and deserialize result', async () => {
       const result = true;
 
-      const serialized = aztecAddNoteSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecAddNoteSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecAddNoteSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecAddNoteSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized).toBe(result);
     });
   });
@@ -78,21 +79,47 @@ describe('Note Serializers', () => {
       const note = await ExtendedNote.random();
       const params = { note };
 
-      const serialized = aztecAddNullifiedNoteSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecAddNullifiedNoteSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecAddNullifiedNoteSerializer.params.deserialize(METHOD, serialized);
+      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', () => {
+    it('should serialize and deserialize result', async () => {
       const result = true;
 
-      const serialized = aztecAddNullifiedNoteSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecAddNullifiedNoteSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecAddNullifiedNoteSerializer.result.deserialize(METHOD, serialized);
+      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();
+    });
+  });
 });

package/src/serializers/note.ts

@@ -1,6 +1,6 @@
 import type { AztecWalletMethodMap } from '../types.js';
 import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import { UniqueNote, TxHash } from '@aztec/circuit-types';
+import { UniqueNote, TxHash, type NotesFilter } from '@aztec/circuit-types';
 import { ExtendedNote, AztecAddress, Fr } from '@aztec/aztec.js';
 
 /**
@@ -21,10 +21,10 @@ export class AztecGetNotesSerializer
      * @param value - The parameters containing filter criteria for notes
      * @returns Serialized filter data
      */
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getNotes']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { filter } = value;
       // Convert instances to their string representations for transport
       const serializedFilter = {
@@ -37,39 +37,38 @@ export class AztecGetNotesSerializer
         scopes: filter.scopes?.map((scope) => scope.toString()),
       };
 
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({ filter: serializedFilter }),
-      };
+      });
     },
     /**
      * Deserializes notes filter parameters from RPC transport.
-     * @param method - The RPC method name
+     * @param _method - The RPC method name
      * @param data - The serialized filter data
      * @returns Deserialized filter parameters
      */
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getNotes']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_getNotes']['params']> => {
       const { filter } = JSON.parse(data.serialized);
 
       // Convert string representations back to instances
-      return {
-        filter: {
-          txHash: filter.txHash ? TxHash.fromString(filter.txHash) : undefined,
-          contractAddress: filter.contractAddress
-            ? AztecAddress.fromString(filter.contractAddress)
-            : undefined,
-          storageSlot: filter.storageSlot ? Fr.fromString(filter.storageSlot) : undefined,
-          owner: filter.owner ? AztecAddress.fromString(filter.owner) : undefined,
-          status: filter.status,
-          siloedNullifier: filter.siloedNullifier ? Fr.fromString(filter.siloedNullifier) : undefined,
-          scopes: filter.scopes
-            ? filter.scopes.map((scope: string) => AztecAddress.fromString(scope))
-            : undefined,
-        },
-      };
+      const notesFilter: NotesFilter = {};
+      if (filter.txHash) notesFilter.txHash = TxHash.fromString(filter.txHash);
+      if (filter.contractAddress)
+        notesFilter.contractAddress = AztecAddress.fromString(filter.contractAddress);
+      if (filter.storageSlot) notesFilter.storageSlot = Fr.fromString(filter.storageSlot);
+      if (filter.owner) notesFilter.owner = AztecAddress.fromString(filter.owner);
+      if (filter.status) notesFilter.status = filter.status;
+      if (filter.siloedNullifier) notesFilter.siloedNullifier = Fr.fromString(filter.siloedNullifier);
+      if (filter.scopes)
+        notesFilter.scopes = filter.scopes.map((scope: string) => AztecAddress.fromString(scope));
+
+      return Promise.resolve({
+        filter: notesFilter,
+      });
     },
   };
 
@@ -80,26 +79,26 @@ export class AztecGetNotesSerializer
      * @param value - Array of unique notes matching the filter criteria
      * @returns Serialized note array
      */
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_getNotes']['result'],
-    ): JSONRPCSerializedData => {
-      return {
+    ): Promise<JSONRPCSerializedData> => {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify(value.map((n) => n.toString())),
-      };
+      });
     },
     /**
      * Deserializes the notes query result.
-     * @param method - The RPC method name
+     * @param _method - The RPC method name
      * @param data - The serialized note array data
      * @returns Array of deserialized unique notes
      */
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getNotes']['result'] => {
-      return JSON.parse(data.serialized).map((n: string) => UniqueNote.fromString(n));
+    ): Promise<AztecWalletMethodMap['aztec_getNotes']['result']> => {
+      return Promise.resolve(JSON.parse(data.serialized).map((n: string) => UniqueNote.fromString(n)));
     },
   };
 }
@@ -122,29 +121,29 @@ export class AztecAddNoteSerializer
      * @param value - The parameters containing the note to add
      * @returns Serialized note data
      */
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_addNote']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { note } = value;
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({ note: note.toBuffer().toString('base64') }),
-      };
+      });
     },
     /**
      * Deserializes note addition parameters from RPC transport.
-     * @param method - The RPC method name
+     * @param _method - The RPC method name
      * @param data - The serialized note data
      * @returns Deserialized note parameters
      */
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_addNote']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_addNote']['params']> => {
       const { note: noteBase64 } = JSON.parse(data.serialized);
       const note = ExtendedNote.fromBuffer(Buffer.from(noteBase64, 'base64'));
-      return { note };
+      return Promise.resolve({ note });
     },
   };
 
@@ -155,20 +154,20 @@ export class AztecAddNoteSerializer
      * @param value - Boolean indicating success of the note addition
      * @returns Serialized result
      */
-    serialize: (method: string, value: boolean): JSONRPCSerializedData => {
-      return {
+    serialize: async (method: string, value: boolean): Promise<JSONRPCSerializedData> => {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify(value),
-      };
+      });
     },
     /**
      * Deserializes the note addition result.
-     * @param method - The RPC method name
+     * @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(data.serialized);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<boolean> => {
+      return Promise.resolve(JSON.parse(data.serialized));
     },
   };
 }
@@ -191,29 +190,29 @@ export class AztecAddNullifiedNoteSerializer
      * @param value - The parameters containing the nullified note to add
      * @returns Serialized note data
      */
-    serialize: (
+    serialize: async (
       method: string,
       value: AztecWalletMethodMap['aztec_addNullifiedNote']['params'],
-    ): JSONRPCSerializedData => {
+    ): Promise<JSONRPCSerializedData> => {
       const { note } = value;
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({ note: note.toBuffer().toString('base64') }),
-      };
+      });
     },
     /**
      * Deserializes nullified note addition parameters from RPC transport.
-     * @param method - The RPC method name
+     * @param _method - The RPC method name
      * @param data - The serialized note data
      * @returns Deserialized note parameters
      */
-    deserialize: (
-      method: string,
+    deserialize: async (
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_addNullifiedNote']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_addNullifiedNote']['params']> => {
       const { note: noteBase64 } = JSON.parse(data.serialized);
       const note = ExtendedNote.fromBuffer(Buffer.from(noteBase64, 'base64'));
-      return { note };
+      return Promise.resolve({ note });
     },
   };
 
@@ -224,20 +223,20 @@ export class AztecAddNullifiedNoteSerializer
      * @param value - Boolean indicating success of the nullified note addition
      * @returns Serialized result
      */
-    serialize: (method: string, value: boolean): JSONRPCSerializedData => {
-      return {
+    serialize: async (method: string, value: boolean): Promise<JSONRPCSerializedData> => {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify(value),
-      };
+      });
     },
     /**
      * Deserializes the nullified note addition result.
-     * @param method - The RPC method name
+     * @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(data.serialized);
+    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<boolean> => {
+      return Promise.resolve(JSON.parse(data.serialized));
     },
   };
 }