@walletmesh/aztec-rpc-wallet 0.2.0 → 0.3.0

package/src/serializers/index.ts

@@ -19,9 +19,8 @@ import {
   aztecGetAuthWitnessSerializer,
 } from './account.js';
 import {
-  aztecGetContractInstanceSerializer,
-  aztecGetContractClassSerializer,
-  aztecGetContractArtifactSerializer,
+  aztecGetContractMetadataSerializer,
+  aztecGetContractClassMetadataSerializer,
   aztecRegisterContractSerializer,
 } from './contract.js';
 import {
@@ -60,9 +59,8 @@ const methodSerializers: Record<AztecMethodName, JSONRPCSerializer<unknown, unkn
   aztec_getAuthWitness: aztecGetAuthWitnessSerializer,
 
   // Contract methods
-  aztec_getContractInstance: aztecGetContractInstanceSerializer,
-  aztec_getContractClass: aztecGetContractClassSerializer,
-  aztec_getContractArtifact: aztecGetContractArtifactSerializer,
+  aztec_getContractMetadata: aztecGetContractMetadataSerializer,
+  aztec_getContractClassMetadata: aztecGetContractClassMetadataSerializer,
   aztec_registerContract: aztecRegisterContractSerializer,
 
   // Transaction methods
@@ -93,11 +91,11 @@ const methodSerializers: Record<AztecMethodName, JSONRPCSerializer<unknown, unkn
  * @param value - The value to wrap
  * @returns Standardized JSON-RPC data structure
  */
-function wrapUnknownValue(method: string, value: unknown): JSONRPCSerializedData {
-  return {
+async function wrapUnknownValue(method: string, value: unknown): Promise<JSONRPCSerializedData> {
+  return Promise.resolve({
     method,
     serialized: JSON.stringify(value),
-  };
+  });
 }
 
 /**
@@ -108,10 +106,6 @@ function wrapUnknownValue(method: string, value: unknown): JSONRPCSerializedData
  * 1. Routes each method call to its specialized serializer from methodSerializers
  * 2. Provides fallback handling for unknown methods
  * 3. Wraps all serialization operations in proper error handling
- *
- * The serializer handles both:
- * - Parameters: Incoming RPC call parameters
- * - Results: Outgoing RPC call results
  */
 export const AztecWalletSerializer: JSONRPCSerializer<unknown, unknown> = {
   params: {
@@ -122,14 +116,14 @@ export const AztecWalletSerializer: JSONRPCSerializer<unknown, unknown> = {
      * @returns Serialized parameter data
      * @throws If serialization fails or encounters an error
      */
-    serialize: (method: string, value: unknown): JSONRPCSerializedData => {
+    serialize: async (method: string, value: unknown): Promise<JSONRPCSerializedData> => {
       const serializer = methodSerializers[method as AztecMethodName];
       if (!serializer?.params) {
         return wrapUnknownValue(method, value);
       }
 
       try {
-        return serializer.params.serialize(method, value);
+        return await serializer.params.serialize(method, value);
       } catch (error) {
         throw new Error(`Failed to serialize params for method ${method}: ${error}`);
       }
@@ -141,14 +135,14 @@ export const AztecWalletSerializer: JSONRPCSerializer<unknown, unknown> = {
      * @returns Deserialized parameters
      * @throws If deserialization fails or encounters an error
      */
-    deserialize: (method: string, data: JSONRPCSerializedData): unknown => {
+    deserialize: async (method: string, data: JSONRPCSerializedData): Promise<unknown> => {
       const serializer = methodSerializers[method as AztecMethodName];
       if (!serializer?.params) {
         return data;
       }
 
       try {
-        return serializer.params.deserialize(method, data);
+        return await serializer.params.deserialize(method, data);
       } catch (error) {
         throw new Error(`Failed to deserialize params for method ${method}: ${error}`);
       }
@@ -162,14 +156,14 @@ export const AztecWalletSerializer: JSONRPCSerializer<unknown, unknown> = {
      * @returns Serialized result data
      * @throws If serialization fails or encounters an error
      */
-    serialize: (method: string, value: unknown): JSONRPCSerializedData => {
+    serialize: async (method: string, value: unknown): Promise<JSONRPCSerializedData> => {
       const serializer = methodSerializers[method as AztecMethodName];
       if (!serializer?.result) {
         return wrapUnknownValue(method, value);
       }
 
       try {
-        return serializer.result.serialize(method, value);
+        return await serializer.result.serialize(method, value);
       } catch (error) {
         throw new Error(`Failed to serialize result for method ${method}: ${error}`);
       }
@@ -181,14 +175,14 @@ export const AztecWalletSerializer: JSONRPCSerializer<unknown, unknown> = {
      * @returns Deserialized result
      * @throws If deserialization fails or encounters an error
      */
-    deserialize: (method: string, data: JSONRPCSerializedData): unknown => {
+    deserialize: async (method: string, data: JSONRPCSerializedData): Promise<unknown> => {
       const serializer = methodSerializers[method as AztecMethodName];
       if (!serializer?.result) {
         return data;
       }
 
       try {
-        return serializer.result.deserialize(method, data);
+        return await serializer.result.deserialize(method, data);
       } catch (error) {
         throw new Error(`Failed to deserialize result for method ${method}: ${error}`);
       }

package/src/serializers/log.test.ts

@@ -18,10 +18,6 @@ import {
 } from './log.js';
 
 describe('Log Serializers', () => {
-  const createRandomLog = async () => {
-    const log = await ExtendedPublicLog.random();
-    return log;
-  };
   describe('aztec_getPublicLogs', () => {
     const METHOD = 'aztec_getPublicLogs';
 
@@ -36,10 +32,10 @@ describe('Log Serializers', () => {
 
       const params = { filter };
 
-      const serialized = aztecGetPublicLogsSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetPublicLogsSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPublicLogsSerializer.params.deserialize(METHOD, serialized);
+      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);
@@ -54,11 +50,13 @@ describe('Log Serializers', () => {
         maxLogsHit: false,
       };
 
-      const serialized = aztecGetPublicLogsSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecGetPublicLogsSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPublicLogsSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized.logs[0].toString()).toBe(result.logs[0].toString());
+      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);
     });
@@ -82,10 +80,10 @@ describe('Log Serializers', () => {
         vpks: [await Point.random(), await Point.random()],
       };
 
-      const serialized = aztecGetPrivateEventsSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetPrivateEventsSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPrivateEventsSerializer.params.deserialize(METHOD, serialized);
+      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);
@@ -98,7 +96,7 @@ describe('Log Serializers', () => {
   describe('aztec_getPublicEvents', () => {
     const METHOD = 'aztec_getPublicEvents';
 
-    it('should serialize and deserialize params', () => {
+    it('should serialize and deserialize params', async () => {
       const event = {
         eventSelector: EventSelector.fromString('0x12345678'),
         abiType: {
@@ -112,10 +110,10 @@ describe('Log Serializers', () => {
         limit: 10,
       };
 
-      const serialized = aztecGetPublicEventsSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetPublicEventsSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPublicEventsSerializer.params.deserialize(METHOD, serialized);
+      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);
@@ -141,10 +139,10 @@ describe('Log Serializers', () => {
       };
 
       const params = { filter };
-      const serialized = aztecGetContractClassLogsSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetContractClassLogsSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetContractClassLogsSerializer.params.deserialize(METHOD, serialized);
+      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);
@@ -152,17 +150,17 @@ describe('Log Serializers', () => {
       expect(deserialized.filter.afterLog?.toString()).toBe(filter.afterLog?.toString());
     });
 
-    it('should serialize and deserialize params with minimal filter', () => {
+    it('should serialize and deserialize params with minimal filter', async () => {
       const filter: LogFilter = {
         fromBlock: 0,
         toBlock: 100,
       };
 
       const params = { filter };
-      const serialized = aztecGetContractClassLogsSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetContractClassLogsSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetContractClassLogsSerializer.params.deserialize(METHOD, serialized);
+      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);
@@ -177,10 +175,10 @@ describe('Log Serializers', () => {
         maxLogsHit: false,
       };
 
-      const serialized = aztecGetContractClassLogsSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecGetContractClassLogsSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetContractClassLogsSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetContractClassLogsSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized.logs).toEqual([]);
       expect(deserialized.maxLogsHit).toBe(result.maxLogsHit);
     });
@@ -189,26 +187,26 @@ describe('Log Serializers', () => {
   describe('aztec_getPrivateEvents result handling', () => {
     const METHOD = 'aztec_getPrivateEvents';
 
-    it('should serialize and deserialize empty result array', () => {
+    it('should serialize and deserialize empty result array', async () => {
       const result: unknown[] = [];
-      const serialized = aztecGetPrivateEventsSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecGetPrivateEventsSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPrivateEventsSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetPrivateEventsSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized).toEqual([]);
     });
 
-    it('should serialize and deserialize result with multiple events', () => {
+    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 = aztecGetPrivateEventsSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecGetPrivateEventsSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPrivateEventsSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetPrivateEventsSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized).toEqual(result);
     });
   });
@@ -216,41 +214,39 @@ describe('Log Serializers', () => {
   describe('aztec_getPublicEvents result handling', () => {
     const METHOD = 'aztec_getPublicEvents';
 
-    it('should serialize and deserialize empty result array', () => {
+    it('should serialize and deserialize empty result array', async () => {
       const result: unknown[] = [];
-      const serialized = aztecGetPublicEventsSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecGetPublicEventsSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPublicEventsSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetPublicEventsSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized).toEqual([]);
     });
 
-    it('should serialize and deserialize result with multiple events', () => {
+    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 = aztecGetPublicEventsSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecGetPublicEventsSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetPublicEventsSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetPublicEventsSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized).toEqual(result);
     });
   });
 
   describe('Edge Cases', () => {
-    it('should handle invalid JSON in deserialization', () => {
+    it('should handle invalid JSON in deserialization', async () => {
       const METHOD = 'aztec_getPublicLogs';
       const invalidData = { method: METHOD, serialized: 'invalid json' };
 
-      expect(() => {
-        aztecGetPublicLogsSerializer.params.deserialize(METHOD, invalidData);
-      }).toThrow();
+      await expect(aztecGetPublicLogsSerializer.params.deserialize(METHOD, invalidData)).rejects.toThrow();
     });
 
-    it('should handle malformed event selector', () => {
+    it('should handle malformed event selector', async () => {
       const METHOD = 'aztec_getPublicEvents';
       const params = {
         event: {
@@ -269,24 +265,22 @@ describe('Log Serializers', () => {
         limit: 10,
       };
 
-      expect(() => {
-        aztecGetPublicEventsSerializer.params.serialize(METHOD, params);
-      }).toThrow();
+      await expect(aztecGetPublicEventsSerializer.params.serialize(METHOD, params)).rejects.toThrow();
     });
 
-    it('should handle undefined filter fields', async () => {
+    it('should handle optional filter fields', async () => {
       const METHOD = 'aztec_getPublicLogs';
       const filter: LogFilter = {
-        fromBlock: undefined,
-        toBlock: undefined,
+        fromBlock: 0,
+        toBlock: 0,
       };
 
       const params = { filter };
-      const serialized = aztecGetPublicLogsSerializer.params.serialize(METHOD, params);
-      const deserialized = aztecGetPublicLogsSerializer.params.deserialize(METHOD, serialized);
+      const serialized = await aztecGetPublicLogsSerializer.params.serialize(METHOD, params);
+      const deserialized = await aztecGetPublicLogsSerializer.params.deserialize(METHOD, serialized);
 
-      expect(deserialized.filter.fromBlock).toBeUndefined();
-      expect(deserialized.filter.toBlock).toBeUndefined();
+      expect(deserialized.filter.fromBlock).toBe(0);
+      expect(deserialized.filter.toBlock).toBe(0);
     });
   });
 });

package/src/serializers/log.ts

@@ -22,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 = {
@@ -36,15 +36,15 @@ export class AztecGetPublicLogsSerializer
         fromBlock: filter.fromBlock,
         toBlock: filter.toBlock,
       };
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({ filter: serializedFilter }),
-      };
+      });
     },
-    deserialize: (
+    deserialize: async (
       _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getPublicLogs']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_getPublicLogs']['params']> => {
       const { filter } = JSON.parse(data.serialized);
       const deserializedFilter: Partial<{
         txHash: TxHash;
@@ -61,25 +61,25 @@ export class AztecGetPublicLogsSerializer
       if (filter.fromBlock !== undefined) deserializedFilter.fromBlock = filter.fromBlock;
       if (filter.toBlock !== undefined) deserializedFilter.toBlock = filter.toBlock;
 
-      return { filter: deserializedFilter };
+      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: (
+    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)));
     },
   };
 }
@@ -96,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 = {
@@ -109,15 +109,15 @@ export class AztecGetContractClassLogsSerializer
         fromBlock: filter.fromBlock,
         toBlock: filter.toBlock,
       };
-      return {
+      return Promise.resolve({
         method,
         serialized: JSON.stringify({ filter: serializedFilter }),
-      };
+      });
     },
-    deserialize: (
+    deserialize: async (
       _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getContractClassLogs']['params'] => {
+    ): Promise<AztecWalletMethodMap['aztec_getContractClassLogs']['params']> => {
       const { filter } = JSON.parse(data.serialized);
       const deserializedFilter: LogFilter = {};
 
@@ -128,25 +128,25 @@ export class AztecGetContractClassLogsSerializer
       if (filter.fromBlock !== undefined) deserializedFilter.fromBlock = filter.fromBlock;
       if (filter.toBlock !== undefined) deserializedFilter.toBlock = filter.toBlock;
 
-      return { filter: deserializedFilter };
+      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: (
+    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)));
     },
   };
 }
@@ -163,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: {
@@ -182,12 +182,12 @@ export class AztecGetPrivateEventsSerializer
           limit,
           vpks: vpks?.map((p) => p.toString()),
         }),
-      };
+      });
     },
-    deserialize: (
+    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),
@@ -196,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));
     },
   };
 }
@@ -230,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: {
@@ -248,12 +248,12 @@ export class AztecGetPublicEventsSerializer
           from,
           limit,
         }),
-      };
+      });
     },
-    deserialize: (
+    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),
@@ -262,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));
     },
   };
 }