@walletmesh/aztec-rpc-wallet 0.3.0 → 0.4.0

package/src/serializers/note.ts

@@ -1,250 +0,0 @@
-import type { AztecWalletMethodMap } from '../types.js';
-import type { JSONRPCSerializedData, JSONRPCSerializer } from '@walletmesh/jsonrpc';
-import { UniqueNote, TxHash, type NotesFilter } from '@aztec/circuit-types';
-import { ExtendedNote, AztecAddress, Fr } from '@aztec/aztec.js';
-
-/**
- * Serializer for the aztec_getNotes RPC method.
- * Handles serialization of note queries and results between JSON-RPC format and native Aztec types.
- */
-export class AztecGetNotesSerializer
-  implements
-    JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getNotes']['params'],
-      AztecWalletMethodMap['aztec_getNotes']['result']
-    >
-{
-  params = {
-    /**
-     * Serializes notes filter parameters for RPC transport.
-     * @param method - The RPC method name
-     * @param value - The parameters containing filter criteria for notes
-     * @returns Serialized filter data
-     */
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getNotes']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { filter } = value;
-      // Convert instances to their string representations for transport
-      const serializedFilter = {
-        txHash: filter.txHash?.toString(),
-        contractAddress: filter.contractAddress?.toString(),
-        storageSlot: filter.storageSlot?.toString(),
-        owner: filter.owner?.toString(),
-        status: filter.status,
-        siloedNullifier: filter.siloedNullifier?.toString(),
-        scopes: filter.scopes?.map((scope) => scope.toString()),
-      };
-
-      return Promise.resolve({
-        method,
-        serialized: JSON.stringify({ filter: serializedFilter }),
-      });
-    },
-    /**
-     * Deserializes notes filter parameters from RPC transport.
-     * @param _method - The RPC method name
-     * @param data - The serialized filter data
-     * @returns Deserialized filter parameters
-     */
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getNotes']['params']> => {
-      const { filter } = JSON.parse(data.serialized);
-
-      // Convert string representations back to instances
-      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,
-      });
-    },
-  };
-
-  result = {
-    /**
-     * Serializes the notes query result.
-     * @param method - The RPC method name
-     * @param value - Array of unique notes matching the filter criteria
-     * @returns Serialized note array
-     */
-    serialize: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_getNotes']['result'],
-    ): 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 data - The serialized note array data
-     * @returns Array of deserialized unique notes
-     */
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_getNotes']['result']> => {
-      return Promise.resolve(JSON.parse(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.
- */
-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: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_addNote']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { note } = value;
-      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 data - The serialized note data
-     * @returns Deserialized note parameters
-     */
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_addNote']['params']> => {
-      const { note: noteBase64 } = JSON.parse(data.serialized);
-      const note = ExtendedNote.fromBuffer(Buffer.from(noteBase64, 'base64'));
-      return Promise.resolve({ 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: 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 data - The serialized result data
-     * @returns Boolean indicating success
-     */
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<boolean> => {
-      return Promise.resolve(JSON.parse(data.serialized));
-    },
-  };
-}
-
-/**
- * Serializer for the aztec_addNullifiedNote RPC method.
- * Handles serialization of nullified note addition requests between JSON-RPC format and native Aztec types.
- */
-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: async (
-      method: string,
-      value: AztecWalletMethodMap['aztec_addNullifiedNote']['params'],
-    ): Promise<JSONRPCSerializedData> => {
-      const { note } = value;
-      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 data - The serialized note data
-     * @returns Deserialized note parameters
-     */
-    deserialize: async (
-      _method: string,
-      data: JSONRPCSerializedData,
-    ): Promise<AztecWalletMethodMap['aztec_addNullifiedNote']['params']> => {
-      const { note: noteBase64 } = JSON.parse(data.serialized);
-      const note = ExtendedNote.fromBuffer(Buffer.from(noteBase64, 'base64'));
-      return Promise.resolve({ 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: 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 data - The serialized result data
-     * @returns Boolean indicating success
-     */
-    deserialize: async (_method: string, data: JSONRPCSerializedData): Promise<boolean> => {
-      return Promise.resolve(JSON.parse(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 aztecGetNotesSerializer = new AztecGetNotesSerializer();
-export const aztecAddNoteSerializer = new AztecAddNoteSerializer();
-export const aztecAddNullifiedNoteSerializer = new AztecAddNullifiedNoteSerializer();

package/src/serializers/transaction.test.ts

@@ -1,320 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AztecAddress, TxHash, Tx, NoFeePaymentMethod, TxReceipt } from '@aztec/aztec.js';
-import {
-  PrivateExecutionResult,
-  TxProvingResult,
-  FunctionCall,
-  TxEffect,
-  TxSimulationResult,
-  TxStatus,
-  PublicSimulationOutput,
-  SimulationError,
-} from '@aztec/circuit-types';
-import { Fr, FunctionSelector, PrivateKernelTailCircuitPublicInputs } from '@aztec/circuits.js';
-import type { ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
-import { FunctionType } from '@aztec/foundation/abi';
-import {
-  aztecCreateTxExecutionRequestSerializer,
-  aztecSendTxSerializer,
-  aztecGetTxEffectSerializer,
-  aztecGetTxReceiptSerializer,
-  aztecSimulateTxSerializer,
-  aztecProveTxSerializer,
-} from './transaction.js';
-import { TxExecutionRequest } from '@aztec/aztec.js';
-
-import { jsonStringify } from '@aztec/foundation/json-rpc';
-
-describe('Transaction Serializers', () => {
-  describe('aztec_createTxExecutionRequest', () => {
-    const METHOD = 'aztec_createTxExecutionRequest';
-
-    it('should serialize and deserialize params', async () => {
-      const randomTx = await TxExecutionRequest.random();
-      const exec = {
-        calls: [], // Empty calls array since we're just testing serialization
-        fee: {
-          gasSettings: randomTx.txContext.gasSettings,
-          paymentMethod: new NoFeePaymentMethod(),
-        },
-      };
-      const params = { exec };
-
-      const serialized = await aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      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 () => {
-      const randomTx = await TxExecutionRequest.random();
-      const address = await AztecAddress.random();
-      const selector = FunctionSelector.random();
-      const functionCall = new FunctionCall(
-        'transfer',
-        address,
-        selector,
-        FunctionType.PRIVATE,
-        false,
-        [await Fr.random(), await Fr.random()],
-        [{ kind: 'field' }, { kind: 'boolean' }],
-      );
-      const exec: ExecutionRequestInit = {
-        calls: [functionCall],
-        fee: {
-          gasSettings: randomTx.txContext.gasSettings,
-          paymentMethod: new NoFeePaymentMethod(),
-        },
-      };
-      const params = { exec };
-
-      const serialized = await aztecCreateTxExecutionRequestSerializer.params.serialize(METHOD, params);
-      const deserialized = await aztecCreateTxExecutionRequestSerializer.params.deserialize(
-        METHOD,
-        serialized,
-      );
-
-      // 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 = await aztecCreateTxExecutionRequestSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecCreateTxExecutionRequestSerializer.result.deserialize(
-        METHOD,
-        serialized,
-      );
-      expect(deserialized.toString()).toBe(result.toString());
-    });
-  });
-
-  describe('aztec_getTxEffect', () => {
-    const METHOD = 'aztec_getTxEffect';
-
-    it('should serialize and deserialize params', async () => {
-      const txHash = await TxHash.random();
-      const params = { txHash };
-
-      const serialized = await aztecGetTxEffectSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetTxEffectSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.txHash.toString()).toBe(txHash.toString());
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const txHash = await TxHash.random();
-      const effect = await TxEffect.random();
-      const blockHash = await Fr.random();
-      const result = {
-        txHash,
-        l2BlockNumber: 123,
-        l2BlockHash: blockHash.toString(),
-        data: effect,
-      };
-
-      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();
-    });
-  });
-
-  describe('aztec_getTxReceipt', () => {
-    const METHOD = 'aztec_getTxReceipt';
-
-    it('should serialize and deserialize params', async () => {
-      const txHash = await TxHash.random();
-      const params = { txHash };
-
-      const serialized = await aztecGetTxReceiptSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecGetTxReceiptSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.txHash.toString()).toBe(txHash.toString());
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const receipt = new TxReceipt(
-        TxHash.random(),
-        TxStatus.DROPPED,
-        'error',
-        undefined,
-        undefined,
-        undefined,
-      );
-
-      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);
-    });
-  });
-
-  describe('aztec_sendTx', () => {
-    const METHOD = 'aztec_sendTx';
-
-    it('should serialize and deserialize params', async () => {
-      const tx = await Tx.random();
-      const params = { tx };
-
-      const serialized = await aztecSendTxSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      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 = await aztecSendTxSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecSendTxSerializer.result.deserialize(METHOD, serialized);
-      expect(deserialized.toString()).toBe(result.toString());
-    });
-  });
-
-  describe('aztec_simulateTx', () => {
-    const METHOD = 'aztec_simulateTx';
-
-    it('should serialize and deserialize params', async () => {
-      const params = {
-        txRequest: await TxExecutionRequest.random(),
-        simulatePublic: true,
-        msgSender: await AztecAddress.random(),
-        skipTxValidation: false,
-        enforceFeePayment: true,
-        profile: false,
-      };
-
-      const serialized = await aztecSimulateTxSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      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());
-      expect(deserialized.skipTxValidation).toBe(params.skipTxValidation);
-      expect(deserialized.enforceFeePayment).toBe(params.enforceFeePayment);
-      expect(deserialized.profile).toBe(params.profile);
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const result = await TxSimulationResult.random();
-
-      const serialized = await aztecSimulateTxSerializer.result.serialize(METHOD, result);
-      const deserialized = await aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
-
-      expect(deserialized.privateExecutionResult).toBeDefined();
-      expect(deserialized.publicInputs).toBeDefined();
-      expect(deserialized.publicOutput).toBeDefined();
-
-      expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
-        jsonStringify(result.privateExecutionResult),
-      );
-      expect(jsonStringify(deserialized.publicInputs)).toEqual(jsonStringify(result.publicInputs));
-      if (!result.publicOutput || !deserialized.publicOutput) {
-        // Should never happen
-        throw new Error('Public output is undefined');
-      }
-      expect(jsonStringify(deserialized.publicOutput.constants)).toEqual(
-        jsonStringify(result.publicOutput.constants),
-      );
-      expect(jsonStringify(deserialized.publicOutput.constants)).toEqual(
-        jsonStringify(result.publicOutput.constants),
-      );
-      expect(jsonStringify(deserialized.publicOutput.gasUsed.publicGas)).toEqual(
-        jsonStringify(result.publicOutput.gasUsed.publicGas),
-      );
-      expect(jsonStringify(deserialized.publicOutput.gasUsed.teardownGas)).toEqual(
-        jsonStringify(result.publicOutput.gasUsed.teardownGas),
-      );
-      expect(jsonStringify(deserialized.publicOutput.gasUsed.totalGas)).toEqual(
-        jsonStringify(result.publicOutput.gasUsed.totalGas),
-      );
-    });
-
-    it('should handle simulation errors in result', async () => {
-      const privateExecutionResult = await PrivateExecutionResult.random();
-      const publicInputs = PrivateKernelTailCircuitPublicInputs.empty();
-      const publicOutput = await PublicSimulationOutput.random();
-      // Simulate an error by setting revertReason
-      publicOutput.revertReason = await SimulationError.random();
-      const result = new TxSimulationResult(privateExecutionResult, publicInputs, publicOutput, undefined);
-
-      const serialized = await aztecSimulateTxSerializer.result.serialize(METHOD, result);
-      const deserialized = await aztecSimulateTxSerializer.result.deserialize(METHOD, serialized);
-
-      const output = deserialized.publicOutput;
-      expect(output).toBeDefined();
-      if (output && result.publicOutput) {
-        expect(output.revertReason).toBeDefined();
-        expect(output.gasUsed).toEqual(result.publicOutput.gasUsed);
-      }
-    });
-  });
-
-  describe('aztec_proveTx', () => {
-    const METHOD = 'aztec_proveTx';
-
-    it('should serialize and deserialize params', async () => {
-      const txRequest = await TxExecutionRequest.random();
-      const privateExecutionResult = await PrivateExecutionResult.random();
-      const params = { txRequest, privateExecutionResult };
-
-      const serialized = await aztecProveTxSerializer.params.serialize(METHOD, params);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecProveTxSerializer.params.deserialize(METHOD, serialized);
-      expect(deserialized.txRequest.toString()).toBe(txRequest.toString());
-      expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
-        jsonStringify(privateExecutionResult),
-      );
-    });
-
-    it('should serialize and deserialize result', async () => {
-      const result = await TxProvingResult.random();
-
-      const serialized = await aztecProveTxSerializer.result.serialize(METHOD, result);
-      expect(serialized.method).toBe(METHOD);
-
-      const deserialized = await aztecProveTxSerializer.result.deserialize(METHOD, serialized);
-      expect(jsonStringify(deserialized)).toEqual(jsonStringify(result));
-    });
-
-    it('should handle complex private execution results', async () => {
-      const txRequest = await TxExecutionRequest.random();
-      const privateExecutionResult = await PrivateExecutionResult.random();
-
-      // Add nested executions and complex data
-      const nestedExecution = await PrivateExecutionResult.random();
-      privateExecutionResult.entrypoint.nestedExecutions.push(nestedExecution.entrypoint);
-
-      const params = { txRequest, privateExecutionResult };
-      const serialized = await aztecProveTxSerializer.params.serialize(METHOD, params);
-      const deserialized = await aztecProveTxSerializer.params.deserialize(METHOD, serialized);
-
-      expect(jsonStringify(deserialized.privateExecutionResult)).toEqual(
-        jsonStringify(privateExecutionResult),
-      );
-    });
-  });
-});