@walletmesh/aztec-rpc-wallet 0.2.0 → 0.3.0

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

@@ -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,10 +37,10 @@ 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.
@@ -48,10 +48,10 @@ export class AztecGetNotesSerializer
      * @param data - The serialized filter data
      * @returns Deserialized filter parameters
      */
-    deserialize: (
+    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
@@ -66,9 +66,9 @@ export class AztecGetNotesSerializer
       if (filter.scopes)
         notesFilter.scopes = filter.scopes.map((scope: string) => AztecAddress.fromString(scope));
 
-      return {
+      return Promise.resolve({
         filter: notesFilter,
-      };
+      });
     },
   };
 
@@ -79,14 +79,14 @@ 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.
@@ -94,11 +94,11 @@ export class AztecGetNotesSerializer
      * @param data - The serialized note array data
      * @returns Array of deserialized unique notes
      */
-    deserialize: (
+    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)));
     },
   };
 }
@@ -121,15 +121,15 @@ 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.
@@ -137,13 +137,13 @@ export class AztecAddNoteSerializer
      * @param data - The serialized note data
      * @returns Deserialized note parameters
      */
-    deserialize: (
+    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 });
     },
   };
 
@@ -154,11 +154,11 @@ 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.
@@ -166,8 +166,8 @@ export class AztecAddNoteSerializer
      * @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));
     },
   };
 }
@@ -190,15 +190,15 @@ 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.
@@ -206,13 +206,13 @@ export class AztecAddNullifiedNoteSerializer
      * @param data - The serialized note data
      * @returns Deserialized note parameters
      */
-    deserialize: (
+    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 });
     },
   };
 
@@ -223,11 +223,11 @@ 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.
@@ -235,8 +235,8 @@ export class AztecAddNullifiedNoteSerializer
      * @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));
     },
   };
 }

package/src/serializers/transaction.test.ts

@@ -40,11 +40,16 @@ describe('Transaction Serializers', () => {
       };
       const params = { exec };
 
-      const serialized = aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecCreateTxExecutionRequestSerializer.params.deserialize(METHOD, serialized);
-      expect(JSON.stringify(deserialized.exec)).toBe(JSON.stringify(params.exec));
+      const deserialized = await aztecCreateTxExecutionRequestSerializer.params.deserialize(
+        METHOD,
+        serialized,
+      );
+      expect(deserialized.exec.calls).toEqual([]);
+      expect(deserialized.exec.fee.gasSettings.equals(randomTx.txContext.gasSettings)).toBe(true);
+      expect(deserialized.exec.fee.paymentMethod).toBeDefined();
     });
 
     it('should handle complex function calls in params', async () => {
@@ -69,30 +74,32 @@ describe('Transaction Serializers', () => {
       };
       const params = { exec };
 
-      const serialized = aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
-      const deserialized = aztecCreateTxExecutionRequestSerializer.params.deserialize(METHOD, serialized);
+      const serialized = await aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
+      const deserialized = await aztecCreateTxExecutionRequestSerializer.params.deserialize(
+        METHOD,
+        serialized,
+      );
 
-      expect(deserialized.exec.calls[0].name).toBe(exec.calls[0].name);
-      expect(deserialized.exec.calls[0].to.toString()).toBe(exec.calls[0].to.toString());
-      expect(deserialized.exec.calls[0].type).toBe(exec.calls[0].type);
+      // biome-ignore lint/style/noNonNullAssertion: test
+      expect(deserialized.exec.calls[0]!.name).toBe(exec.calls[0]!.name);
+      // biome-ignore lint/style/noNonNullAssertion: test
+      expect(deserialized.exec.calls[0]!.to.toString()).toBe(exec.calls[0]!.to.toString());
+      // biome-ignore lint/style/noNonNullAssertion: test
+      expect(deserialized.exec.calls[0]!.type).toBe(exec.calls[0]!.type);
     });
 
     it('should serialize and deserialize result', async () => {
       const result = await TxExecutionRequest.random();
 
-      const serialized = aztecCreateTxExecutionRequestSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecCreateTxExecutionRequestSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecCreateTxExecutionRequestSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecCreateTxExecutionRequestSerializer.result.deserialize(
+        METHOD,
+        serialized,
+      );
       expect(deserialized.toString()).toBe(result.toString());
     });
-
-    it('should handle invalid params', () => {
-      expect(() => {
-        // @ts-ignore - Testing invalid input
-        aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, { exec: null });
-      }).toThrow();
-    });
   });
 
   describe('aztec_getTxEffect', () => {
@@ -102,10 +109,10 @@ describe('Transaction Serializers', () => {
       const txHash = await TxHash.random();
       const params = { txHash };
 
-      const serialized = aztecGetTxEffectSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetTxEffectSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetTxEffectSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetTxEffectSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txHash.toString()).toBe(txHash.toString());
     });
 
@@ -120,8 +127,8 @@ describe('Transaction Serializers', () => {
         data: effect,
       };
 
-      const serialized = aztecGetTxEffectSerializer.result.serialize(METHOD, result);
-      const deserialized = aztecGetTxEffectSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecGetTxEffectSerializer.result.serialize(METHOD, result);
+      const deserialized = await aztecGetTxEffectSerializer.result.deserialize(METHOD, serialized);
 
       expect(deserialized.l2BlockNumber).toBe(result.l2BlockNumber);
       expect(deserialized.data).toBeDefined();
@@ -135,10 +142,10 @@ describe('Transaction Serializers', () => {
       const txHash = await TxHash.random();
       const params = { txHash };
 
-      const serialized = aztecGetTxReceiptSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecGetTxReceiptSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecGetTxReceiptSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecGetTxReceiptSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txHash.toString()).toBe(txHash.toString());
     });
 
@@ -152,8 +159,8 @@ describe('Transaction Serializers', () => {
         undefined,
       );
 
-      const serialized = aztecGetTxReceiptSerializer.result.serialize(METHOD, receipt);
-      const deserialized = aztecGetTxReceiptSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecGetTxReceiptSerializer.result.serialize(METHOD, receipt);
+      const deserialized = await aztecGetTxReceiptSerializer.result.deserialize(METHOD, serialized);
 
       expect(deserialized.txHash.toString()).toBe(receipt.txHash.toString());
       expect(deserialized.error).toBe(receipt.error);
@@ -167,20 +174,20 @@ describe('Transaction Serializers', () => {
       const tx = await Tx.random();
       const params = { tx };
 
-      const serialized = aztecSendTxSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecSendTxSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecSendTxSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecSendTxSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.tx.toBuffer().toString('hex')).toBe(tx.toBuffer().toString('hex'));
     });
 
     it('should serialize and deserialize result', async () => {
       const result = await TxHash.random();
 
-      const serialized = aztecSendTxSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecSendTxSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecSendTxSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecSendTxSerializer.result.deserialize(METHOD, serialized);
       expect(deserialized.toString()).toBe(result.toString());
     });
   });
@@ -198,10 +205,10 @@ describe('Transaction Serializers', () => {
         profile: false,
       };
 
-      const serialized = aztecSimulateTxSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecSimulateTxSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecSimulateTxSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecSimulateTxSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txRequest.toString()).toBe((params.txRequest as TxExecutionRequest).toString());
       expect(deserialized.simulatePublic).toBe(params.simulatePublic);
       expect(deserialized.msgSender?.toString()).toBe(params.msgSender.toString());
@@ -213,8 +220,8 @@ describe('Transaction Serializers', () => {
     it('should serialize and deserialize result', async () => {
       const result = await TxSimulationResult.random();
 
-      const serialized = aztecSimulateTxSerializer.result.serialize(METHOD, result);
-      const deserialized = aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecSimulateTxSerializer.result.serialize(METHOD, result);
+      const deserialized = await aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
 
       expect(deserialized.privateExecutionResult).toBeDefined();
       expect(deserialized.publicInputs).toBeDefined();
@@ -253,8 +260,8 @@ describe('Transaction Serializers', () => {
       publicOutput.revertReason = await SimulationError.random();
       const result = new TxSimulationResult(privateExecutionResult, publicInputs, publicOutput, undefined);
 
-      const serialized = aztecSimulateTxSerializer.result.serialize(METHOD, result);
-      const deserialized = aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
+      const serialized = await aztecSimulateTxSerializer.result.serialize(METHOD, result);
+      const deserialized = await aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
 
       const output = deserialized.publicOutput;
       expect(output).toBeDefined();
@@ -273,10 +280,10 @@ describe('Transaction Serializers', () => {
       const privateExecutionResult = await PrivateExecutionResult.random();
       const params = { txRequest, privateExecutionResult };
 
-      const serialized = aztecProveTxSerializer.params.serialize(METHOD, params);
+      const serialized = await aztecProveTxSerializer.params.serialize(METHOD, params);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecProveTxSerializer.params.deserialize(METHOD, serialized);
+      const deserialized = await aztecProveTxSerializer.params.deserialize(METHOD, serialized);
       expect(deserialized.txRequest.toString()).toBe(txRequest.toString());
       expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
         jsonStringify(privateExecutionResult),
@@ -286,10 +293,10 @@ describe('Transaction Serializers', () => {
     it('should serialize and deserialize result', async () => {
       const result = await TxProvingResult.random();
 
-      const serialized = aztecProveTxSerializer.result.serialize(METHOD, result);
+      const serialized = await aztecProveTxSerializer.result.serialize(METHOD, result);
       expect(serialized.method).toBe(METHOD);
 
-      const deserialized = aztecProveTxSerializer.result.deserialize(METHOD, serialized);
+      const deserialized = await aztecProveTxSerializer.result.deserialize(METHOD, serialized);
       expect(jsonStringify(deserialized)).toEqual(jsonStringify(result));
     });
 
@@ -302,8 +309,8 @@ describe('Transaction Serializers', () => {
       privateExecutionResult.entrypoint.nestedExecutions.push(nestedExecution.entrypoint);
 
       const params = { txRequest, privateExecutionResult };
-      const serialized = aztecProveTxSerializer.params.serialize(METHOD, params);
-      const deserialized = aztecProveTxSerializer.params.deserialize(METHOD, serialized);
+      const serialized = await aztecProveTxSerializer.params.serialize(METHOD, params);
+      const deserialized = await aztecProveTxSerializer.params.deserialize(METHOD, serialized);
 
       expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
         jsonStringify(privateExecutionResult),