@walletmesh/aztec-rpc-wallet 0.1.0 → 0.2.0

package/src/serializers/note.ts

@@ -1,81 +1,104 @@
 import type { AztecWalletMethodMap } from '../types.js';
-import type { JSONRPCSerializedData, JSONRPCSerializer } from './types.js';
-import { encodeBase64, decodeBase64 } from './types.js';
-import type { IncomingNotesFilter } from '@aztec/circuit-types';
-import { UniqueNote } from '@aztec/circuit-types';
-import { ExtendedNote } from '@aztec/aztec.js';
+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_getIncomingNotes RPC method.
- * Handles serialization of incoming note queries and results between JSON-RPC format and native Aztec types.
- * Used to retrieve notes that have been sent to an account but not yet processed.
+ * Serializer for the aztec_getNotes RPC method.
+ * Handles serialization of note queries and results between JSON-RPC format and native Aztec types.
  */
-export class AztecGetIncomingNotesSerializer
+export class AztecGetNotesSerializer
   implements
     JSONRPCSerializer<
-      AztecWalletMethodMap['aztec_getIncomingNotes']['params'],
-      AztecWalletMethodMap['aztec_getIncomingNotes']['result']
+      AztecWalletMethodMap['aztec_getNotes']['params'],
+      AztecWalletMethodMap['aztec_getNotes']['result']
     >
 {
   params = {
     /**
-     * Serializes incoming notes filter parameters for RPC transport.
+     * Serializes notes filter parameters for RPC transport.
      * @param method - The RPC method name
-     * @param value - The parameters containing filter criteria for incoming notes
+     * @param value - The parameters containing filter criteria for notes
      * @returns Serialized filter data
      */
     serialize: (
       method: string,
-      value: AztecWalletMethodMap['aztec_getIncomingNotes']['params'],
+      value: AztecWalletMethodMap['aztec_getNotes']['params'],
     ): 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 {
         method,
-        serialized: encodeBase64(JSON.stringify(filter)),
+        serialized: JSON.stringify({ filter: serializedFilter }),
       };
     },
     /**
-     * Deserializes incoming notes filter parameters from RPC transport.
-     * @param method - The RPC method name
+     * Deserializes notes filter parameters from RPC transport.
+     * @param _method - The RPC method name
      * @param data - The serialized filter data
      * @returns Deserialized filter parameters
      */
     deserialize: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getIncomingNotes']['params'] => {
-      const filter = JSON.parse(decodeBase64(data.serialized)) as IncomingNotesFilter;
-      return { filter };
+    ): 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 {
+        filter: notesFilter,
+      };
     },
   };
 
   result = {
     /**
-     * Serializes the incoming notes query 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: (
       method: string,
-      value: AztecWalletMethodMap['aztec_getIncomingNotes']['result'],
+      value: AztecWalletMethodMap['aztec_getNotes']['result'],
     ): JSONRPCSerializedData => {
       return {
         method,
-        serialized: encodeBase64(JSON.stringify(value.map((n) => n.toString()))),
+        serialized: JSON.stringify(value.map((n) => n.toString())),
       };
     },
     /**
-     * Deserializes the incoming notes query result.
-     * @param method - The RPC method name
+     * 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: (
-      method: string,
+      _method: string,
       data: JSONRPCSerializedData,
-    ): AztecWalletMethodMap['aztec_getIncomingNotes']['result'] => {
-      return JSON.parse(decodeBase64(data.serialized)).map((n: string) => UniqueNote.fromString(n));
+    ): AztecWalletMethodMap['aztec_getNotes']['result'] => {
+      return JSON.parse(data.serialized).map((n: string) => UniqueNote.fromString(n));
     },
   };
 }
@@ -83,7 +106,6 @@ export class AztecGetIncomingNotesSerializer
 /**
  * Serializer for the aztec_addNote RPC method.
  * Handles serialization of note addition requests between JSON-RPC format and native Aztec types.
- * Used to add new notes to an account's note tree.
  */
 export class AztecAddNoteSerializer
   implements
@@ -106,20 +128,21 @@ export class AztecAddNoteSerializer
       const { note } = value;
       return {
         method,
-        serialized: encodeBase64(note.toBuffer().toString('hex')),
+        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,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_addNote']['params'] => {
-      const note = ExtendedNote.fromBuffer(Buffer.from(decodeBase64(data.serialized), 'hex'));
+      const { note: noteBase64 } = JSON.parse(data.serialized);
+      const note = ExtendedNote.fromBuffer(Buffer.from(noteBase64, 'base64'));
       return { note };
     },
   };
@@ -134,17 +157,17 @@ export class AztecAddNoteSerializer
     serialize: (method: string, value: boolean): JSONRPCSerializedData => {
       return {
         method,
-        serialized: encodeBase64(JSON.stringify(value)),
+        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(decodeBase64(data.serialized));
+    deserialize: (_method: string, data: JSONRPCSerializedData): boolean => {
+      return JSON.parse(data.serialized);
     },
   };
 }
@@ -152,7 +175,6 @@ export class AztecAddNoteSerializer
 /**
  * Serializer for the aztec_addNullifiedNote RPC method.
  * Handles serialization of nullified note addition requests between JSON-RPC format and native Aztec types.
- * Used to mark notes as spent/nullified in the note tree.
  */
 export class AztecAddNullifiedNoteSerializer
   implements
@@ -175,20 +197,21 @@ export class AztecAddNullifiedNoteSerializer
       const { note } = value;
       return {
         method,
-        serialized: encodeBase64(note.toBuffer().toString('hex')),
+        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,
+      _method: string,
       data: JSONRPCSerializedData,
     ): AztecWalletMethodMap['aztec_addNullifiedNote']['params'] => {
-      const note = ExtendedNote.fromBuffer(Buffer.from(decodeBase64(data.serialized), 'hex'));
+      const { note: noteBase64 } = JSON.parse(data.serialized);
+      const note = ExtendedNote.fromBuffer(Buffer.from(noteBase64, 'base64'));
       return { note };
     },
   };
@@ -203,17 +226,17 @@ export class AztecAddNullifiedNoteSerializer
     serialize: (method: string, value: boolean): JSONRPCSerializedData => {
       return {
         method,
-        serialized: encodeBase64(JSON.stringify(value)),
+        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(decodeBase64(data.serialized));
+    deserialize: (_method: string, data: JSONRPCSerializedData): boolean => {
+      return JSON.parse(data.serialized);
     },
   };
 }
@@ -222,6 +245,6 @@ export class AztecAddNullifiedNoteSerializer
  * Pre-instantiated serializer instances for Aztec note-related RPC methods.
  * These instances can be used directly by the RPC handler implementation.
  */
-export const aztecGetIncomingNotesSerializer = new AztecGetIncomingNotesSerializer();
+export const aztecGetNotesSerializer = new AztecGetNotesSerializer();
 export const aztecAddNoteSerializer = new AztecAddNoteSerializer();
 export const aztecAddNullifiedNoteSerializer = new AztecAddNullifiedNoteSerializer();

package/src/serializers/transaction-utils.ts

@@ -1,237 +1,174 @@
-import { PrivateExecutionResult, TxProvingResult } from '@aztec/circuit-types';
-import type {
-  CountedContractClassLog,
-  CountedPublicExecutionRequest,
-  NoteAndSlot,
-  PublicExecutionRequest,
-} from '@aztec/circuit-types';
-import type {
-  ClientIvcProof,
-  PrivateCircuitPublicInputs,
-  PrivateKernelTailCircuitPublicInputs,
-} from '@aztec/circuits.js';
-import { Fr } from '@aztec/aztec.js';
-
 /**
- * Interface representing the serialized form of a private execution result.
- * Contains all data needed to reconstruct a PrivateExecutionResult instance.
+ * @module transaction-utils
+ * Utilities for serializing and deserializing Aztec transaction execution requests.
+ * These utilities handle the conversion between native Aztec types and JSON-RPC compatible formats.
  */
-interface SerializedPrivateExecutionResultData {
-  acir: string;
-  vk: string;
-  partialWitness: [number, string][];
-  publicInputs: PrivateCircuitPublicInputs;
-  noteHashLeafIndexMap: [string, string][];
-  newNotes: NoteAndSlot[];
-  noteHashNullifierCounterMap: [number, number][];
-  returnValues: string[];
-  nestedExecutions: SerializedPrivateExecutionResultData[];
-  enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[];
-  publicTeardownFunctionCall: PublicExecutionRequest;
-  contractClassLogs: CountedContractClassLog[];
-}
+
+import { HashedValues, FunctionCall, AuthWitness } from '@aztec/circuit-types';
+import { AztecAddress, Fr, FunctionSelector, GasSettings } from '@aztec/circuits.js';
+import type { FunctionType, AbiType } from '@aztec/foundation/abi';
+import type { ExecutionRequestInit } from '@aztec/aztec.js/entrypoint';
+import { NoFeePaymentMethod } from '@aztec/aztec.js';
 
 /**
- * Extends PrivateExecutionResult to add serialization capabilities.
- * Provides methods to convert private execution results to/from JSON format for RPC transport.
+ * Interface representing the serialized form of a function call.
+ * This structure maps the native FunctionCall type to a JSON-serializable format
+ * where complex Aztec types are converted to strings.
+ *
+ * @property name - The name of the function being called
+ * @property to - The target contract address as a string
+ * @property selector - The function selector as a string
+ * @property type - The function type (public/private)
+ * @property isStatic - Whether the function is static (read-only)
+ * @property args - Array of function arguments as strings
+ * @property returnTypes - Array of return type definitions
  */
-export class SerializablePrivateExecutionResult extends PrivateExecutionResult {
-  /**
-   * Creates a SerializablePrivateExecutionResult from a PrivateExecutionResult instance.
-   * @param result - The PrivateExecutionResult to convert
-   * @returns A new SerializablePrivateExecutionResult instance
-   */
-  static from(result: PrivateExecutionResult): SerializablePrivateExecutionResult {
-    return new SerializablePrivateExecutionResult(
-      result.acir,
-      result.vk,
-      result.partialWitness,
-      result.publicInputs,
-      result.noteHashLeafIndexMap,
-      result.newNotes,
-      result.noteHashNullifierCounterMap,
-      result.returnValues,
-      result.nestedExecutions,
-      result.enqueuedPublicFunctionCalls,
-      result.publicTeardownFunctionCall,
-      result.contractClassLogs,
-    );
-  }
-
-  /**
-   * Converts the execution result to a JSON-serializable format.
-   * Handles conversion of complex types like Buffers, Maps, and nested execution results.
-   * @returns The serialized execution result data
-   */
-  toJSON(): SerializedPrivateExecutionResultData {
-    return {
-      acir: this.acir.toString('base64'),
-      vk: this.vk.toString('base64'),
-      partialWitness: Array.from(this.partialWitness.entries()),
-      publicInputs: this.publicInputs,
-      noteHashLeafIndexMap: Array.from(this.noteHashLeafIndexMap.entries()).map(([k, v]) => [
-        k.toString(),
-        v.toString(),
-      ]),
-      newNotes: this.newNotes,
-      noteHashNullifierCounterMap: Array.from(this.noteHashNullifierCounterMap.entries()),
-      returnValues: this.returnValues.map((fr: Fr) => fr.toString()),
-      nestedExecutions: this.nestedExecutions.map((exec: PrivateExecutionResult) =>
-        exec instanceof SerializablePrivateExecutionResult
-          ? exec.toJSON()
-          : new SerializablePrivateExecutionResult(
-              exec.acir,
-              exec.vk,
-              exec.partialWitness,
-              exec.publicInputs,
-              exec.noteHashLeafIndexMap,
-              exec.newNotes,
-              exec.noteHashNullifierCounterMap,
-              exec.returnValues,
-              exec.nestedExecutions,
-              exec.enqueuedPublicFunctionCalls,
-              exec.publicTeardownFunctionCall,
-              exec.contractClassLogs,
-            ).toJSON(),
-      ),
-      enqueuedPublicFunctionCalls: this.enqueuedPublicFunctionCalls,
-      publicTeardownFunctionCall: this.publicTeardownFunctionCall,
-      contractClassLogs: this.contractClassLogs,
-    };
-  }
-
-  /**
-   * Creates a SerializablePrivateExecutionResult from JSON data.
-   * @param json - JSON string or pre-parsed data object
-   * @returns A new SerializablePrivateExecutionResult instance
-   */
-  static fromJSON(json: string | SerializedPrivateExecutionResultData): SerializablePrivateExecutionResult {
-    const data: SerializedPrivateExecutionResultData = typeof json === 'string' ? JSON.parse(json) : json;
-
-    return new SerializablePrivateExecutionResult(
-      Buffer.from(data.acir, 'base64'),
-      Buffer.from(data.vk, 'base64'),
-      new Map(data.partialWitness),
-      data.publicInputs,
-      new Map(data.noteHashLeafIndexMap.map(([k, v]) => [BigInt(k), BigInt(v)])),
-      data.newNotes,
-      new Map(data.noteHashNullifierCounterMap),
-      data.returnValues.map((str: string) => Fr.fromString(str)),
-      data.nestedExecutions.map((exec: SerializedPrivateExecutionResultData) =>
-        SerializablePrivateExecutionResult.fromJSON(exec),
-      ),
-      data.enqueuedPublicFunctionCalls,
-      data.publicTeardownFunctionCall,
-      data.contractClassLogs,
-    );
-  }
-
-  /**
-   * Compares this execution result with another for equality.
-   * @param other - The execution result to compare against
-   * @returns True if the execution results are equivalent
-   */
-  equals(other: PrivateExecutionResult): boolean {
-    const thisJson = JSON.stringify(SerializablePrivateExecutionResult.from(this).toJSON());
-    const otherJson = JSON.stringify(SerializablePrivateExecutionResult.from(other).toJSON());
-    return thisJson === otherJson;
-  }
-
-  toComparable(): SerializedPrivateExecutionResultData {
-    return JSON.parse(JSON.stringify(this.toJSON()));
-  }
+interface SerializedFunctionCall {
+  name: string;
+  to: string;
+  selector: string;
+  type: FunctionType;
+  isStatic: boolean;
+  args: string[];
+  returnTypes: AbiType[];
 }
 
 /**
- * Interface representing the serialized form of a transaction proving result.
- * Contains the private execution result, public inputs, and client IVC proof.
+ * Interface representing the serialized form of an execution request initialization.
+ * This structure maps the ExecutionRequestInit type to a JSON-serializable format
+ * where complex Aztec types are converted to strings.
+ *
+ * @property calls - Array of serialized function calls
+ * @property authWitnesses - Optional array of authentication witness strings
+ * @property hashedArguments - Optional array of hashed argument values as base64 strings
+ * @property fee - Fee settings including gas configuration
+ * @property nonce - Optional transaction nonce as a string
+ * @property cancellable - Optional flag indicating if the transaction can be cancelled
  */
-interface SerializedTxProvingResultData {
-  privateExecutionResult: ReturnType<SerializablePrivateExecutionResult['toJSON']>;
-  publicInputs: PrivateKernelTailCircuitPublicInputs;
-  clientIvcProof: ClientIvcProof;
+interface SerializedExecutionRequestInit {
+  calls: SerializedFunctionCall[];
+  authWitnesses?: string[];
+  hashedArguments?: string[];
+  fee: {
+    gasSettings: string;
+  };
+  nonce?: string;
+  cancellable?: boolean;
 }
 
 /**
- * Extends TxProvingResult to add serialization capabilities.
- * Provides methods to convert transaction proving results to/from JSON format for RPC transport.
+ * Serializes an ExecutionRequestInit object to a string for JSON-RPC transport.
+ * This function converts a native Aztec transaction execution request into a format
+ * that can be safely transmitted over JSON-RPC, handling the conversion of complex
+ * types like addresses, field elements, and function selectors to strings.
+ *
+ * Note: The fee payment method is not serialized as it contains async methods.
+ * The deserializer will use a default NoFeePaymentMethod which should be replaced
+ * by the caller with an appropriate implementation.
+ *
+ * @param init - The ExecutionRequestInit object to serialize, containing:
+ *               - calls: Array of function calls to execute
+ *               - fee: Gas settings and payment method
+ *               - authWitnesses: Optional authentication proofs
+ *               - hashedArguments: Optional pre-hashed arguments
+ *               - nonce: Optional transaction nonce
+ *               - cancellable: Optional cancellation flag
+ * @returns A JSON string representation of the serialized data, with all complex
+ *          Aztec types converted to string representations
+ * @throws If any of the complex types cannot be serialized
  */
-export class SerializableTxProvingResult extends TxProvingResult {
-  /**
-   * Creates a SerializableTxProvingResult from a TxProvingResult instance.
-   * @param result - The TxProvingResult to convert
-   * @returns A new SerializableTxProvingResult instance
-   */
-  static from(result: TxProvingResult): SerializableTxProvingResult {
-    return new SerializableTxProvingResult(
-      result.privateExecutionResult,
-      result.publicInputs,
-      result.clientIvcProof,
-    );
+export function serializeExecutionRequestInit(init: ExecutionRequestInit): string {
+  const serialized: SerializedExecutionRequestInit = {
+    calls: init.calls.map((call) => ({
+      name: call.name,
+      to: call.to.toString(),
+      selector: call.selector.toString(),
+      type: call.type,
+      isStatic: call.isStatic,
+      args: call.args.map((arg) => arg.toString()),
+      returnTypes: call.returnTypes,
+    })),
+    fee: {
+      gasSettings: init.fee.gasSettings.toBuffer().toString('base64'),
+    },
+  };
+
+  if (init.authWitnesses) {
+    serialized.authWitnesses = init.authWitnesses.map((w) => w.toString());
   }
 
-  /**
-   * Converts the proving result to a JSON-serializable format.
-   * @returns The serialized proving result data
-   */
-  toJSON(): SerializedTxProvingResultData {
-    return {
-      privateExecutionResult: SerializablePrivateExecutionResult.from(this.privateExecutionResult).toJSON(),
-      publicInputs: this.publicInputs,
-      clientIvcProof: this.clientIvcProof,
-    };
+  if (init.hashedArguments) {
+    serialized.hashedArguments = init.hashedArguments.map((ha) => ha.toBuffer().toString('base64'));
   }
 
-  /**
-   * Creates a SerializableTxProvingResult from JSON data.
-   * @param json - JSON string or pre-parsed data object
-   * @returns A new SerializableTxProvingResult instance
-   */
-  static fromJSON(json: string | SerializedTxProvingResultData): SerializableTxProvingResult {
-    const data: SerializedTxProvingResultData = typeof json === 'string' ? JSON.parse(json) : json;
-
-    return new SerializableTxProvingResult(
-      SerializablePrivateExecutionResult.fromJSON(data.privateExecutionResult),
-      data.publicInputs,
-      data.clientIvcProof,
-    );
+  if (init.nonce) {
+    serialized.nonce = init.nonce.toString();
   }
 
-  /**
-   * Compares this proving result with another for equality.
-   * @param other - The proving result to compare against
-   * @returns True if the proving results are equivalent
-   */
-  equals(other: TxProvingResult): boolean {
-    const thisJson = JSON.stringify(SerializableTxProvingResult.from(this).toJSON());
-    const otherJson = JSON.stringify(SerializableTxProvingResult.from(other).toJSON());
-    return thisJson === otherJson;
+  if (init.cancellable !== undefined) {
+    serialized.cancellable = init.cancellable;
   }
 
-  toComparable(): SerializedTxProvingResultData {
-    return JSON.parse(JSON.stringify(this.toJSON()));
-  }
+  return JSON.stringify(serialized);
 }
 
 /**
- * Utility function to compare two PrivateExecutionResult instances for equality.
- * @param a - First execution result
- * @param b - Second execution result
- * @returns True if the execution results are equivalent
+ * Deserializes a string into an ExecutionRequestInit object for use in the Aztec protocol.
+ * This function reconstructs a native Aztec transaction execution request from its
+ * JSON-RPC serialized form, converting string representations back into their
+ * appropriate Aztec types.
+ *
+ * Note: A default NoFeePaymentMethod is used for the fee payment method.
+ * The caller should override this with the appropriate implementation based on
+ * their fee payment requirements.
+ *
+ * @param data - The serialized string data containing:
+ *               - calls: Array of serialized function calls
+ *               - fee: Serialized gas settings
+ *               - authWitnesses: Optional serialized authentication proofs
+ *               - hashedArguments: Optional serialized hashed arguments
+ *               - nonce: Optional serialized nonce
+ *               - cancellable: Optional cancellation flag
+ * @returns The deserialized ExecutionRequestInit object with all string representations
+ *          converted back to their native Aztec types
+ * @throws If any of the serialized data cannot be properly deserialized into valid Aztec types
  */
-export function comparePrivateExecutionResults(
-  a: PrivateExecutionResult,
-  b: PrivateExecutionResult,
-): boolean {
-  return SerializablePrivateExecutionResult.from(a).equals(b);
-}
+export function deserializeExecutionRequestInit(data: string): ExecutionRequestInit {
+  const parsed: SerializedExecutionRequestInit = JSON.parse(data);
+
+  const result: ExecutionRequestInit = {
+    calls: parsed.calls.map(
+      (call) =>
+        new FunctionCall(
+          call.name,
+          AztecAddress.fromString(call.to),
+          FunctionSelector.fromString(call.selector),
+          call.type,
+          call.isStatic,
+          call.args.map((arg) => Fr.fromString(arg)),
+          call.returnTypes,
+        ),
+    ),
+    fee: {
+      gasSettings: GasSettings.fromBuffer(Buffer.from(parsed.fee.gasSettings, 'base64')),
+      paymentMethod: new NoFeePaymentMethod(), // Default, caller should override
+    },
+  };
+
+  if (parsed.authWitnesses) {
+    result.authWitnesses = parsed.authWitnesses.map((w) => AuthWitness.fromString(w));
+  }
+  if (parsed.hashedArguments) {
+    result.hashedArguments = parsed.hashedArguments.map((ha) =>
+      HashedValues.fromBuffer(Buffer.from(ha, 'base64')),
+    );
+  }
+  if (parsed.nonce) {
+    result.nonce = Fr.fromString(parsed.nonce);
+  }
+  if (parsed.cancellable !== undefined) {
+    result.cancellable = parsed.cancellable;
+  }
 
-/**
- * Utility function to compare two TxProvingResult instances for equality.
- * @param a - First proving result
- * @param b - Second proving result
- * @returns True if the proving results are equivalent
- */
-export function compareTxProvingResults(a: TxProvingResult, b: TxProvingResult): boolean {
-  return SerializableTxProvingResult.from(a).equals(b);
+  return result;
 }