@aztec/simulator 0.80.0 → 0.82.0

package/src/private/execution_data_provider.ts

@@ -1,5 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { FunctionArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { Fr, Point } from '@aztec/foundation/fields';
+import type { FunctionArtifact, FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
@@ -9,7 +9,7 @@ import type { NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
-import type { CommitmentsDB } from '../common/db_interfaces.js';
+import type { CommitmentsDBInterface } from '../common/db_interfaces.js';
 import type { NoteData } from './acvm/index.js';
 
 /**
@@ -33,7 +33,7 @@ export class ContractClassNotFoundError extends Error {
 /**
  * The interface for the data layer required to perform private and unconstrained execution.
  */
-export interface ExecutionDataProvider extends CommitmentsDB {
+export interface ExecutionDataProvider extends CommitmentsDBInterface {
   /**
    * Returns a contract instance associated with an address, if available.
    * @param address - Address.
@@ -49,13 +49,6 @@ export interface ExecutionDataProvider extends CommitmentsDB {
    */
   getCompleteAddress(account: AztecAddress): Promise<CompleteAddress>;
 
-  /**
-   * Retrieve the auth witness for a given message hash.
-   * @param messageHash - The message hash.
-   * @returns A Promise that resolves to an array of field elements representing the auth witness.
-   */
-  getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
-
   /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.
@@ -90,7 +83,10 @@ export interface ExecutionDataProvider extends CommitmentsDB {
    * @param selector - The corresponding function selector.
    * @returns A Promise that resolves to a FunctionArtifact object.
    */
-  getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
+  getFunctionArtifact(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName>;
 
   /**
    * Generates a stable function name for debug purposes.
@@ -157,7 +153,7 @@ export interface ExecutionDataProvider extends CommitmentsDB {
    * @param blockNumber - The block number at which to get the witness.
    * @param leafSlot - The slot of the public data in the public data tree.
    */
-  getPublicDataTreeWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  getPublicDataWitness(blockNumber: number, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
 
   /**
    * Gets the storage value at the given contract storage slot.
@@ -239,10 +235,11 @@ export interface ExecutionDataProvider extends CommitmentsDB {
 
   /**
    * Processes the tagged logs returned by syncTaggedLogs by decrypting them and storing them in the database.
+   * @param contractAddress - The address of the contract that emitted the logs.
    * @param logs - The logs to process.
    * @param recipient - The recipient of the logs.
    */
-  processTaggedLogs(logs: TxScopedL2Log[], recipient: AztecAddress): Promise<void>;
+  processTaggedLogs(contractAddress: AztecAddress, logs: TxScopedL2Log[], recipient: AztecAddress): Promise<void>;
 
   /**
    * Delivers the preimage and metadata of a committed note so that it can be later requested via the `getNotes`
@@ -320,4 +317,12 @@ export interface ExecutionDataProvider extends CommitmentsDB {
    * @param numEntries - The number of entries to copy.
    */
   copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
+
+  /**
+   * Retrieves the shared secret for a given address and ephemeral public key.
+   * @param address - The address to get the secret for.
+   * @param ephPk - The ephemeral public key to get the secret for.
+   * @returns The secret for the given address.
+   */
+  getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
 }

package/src/private/private_execution.ts

@@ -3,7 +3,12 @@ import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type FunctionArtifact, type FunctionSelector, countArgumentsSize } from '@aztec/stdlib/abi';
+import {
+  type FunctionArtifact,
+  type FunctionArtifactWithContractName,
+  type FunctionSelector,
+  countArgumentsSize,
+} from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstance } from '@aztec/stdlib/contract';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
@@ -13,7 +18,7 @@ import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
 
 import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
-import { fromACVMField, witnessMapToFields } from './acvm/deserialize.js';
+import { witnessMapToFields } from './acvm/deserialize.js';
 import { type ACVMWitness, Oracle, extractCallStack } from './acvm/index.js';
 import type { ExecutionDataProvider } from './execution_data_provider.js';
 import type { PrivateExecutionOracle } from './private_execution_oracle.js';
@@ -25,19 +30,18 @@ import type { SimulationProvider } from './providers/simulation_provider.js';
 export async function executePrivateFunction(
   simulator: SimulationProvider,
   privateExecutionOracle: PrivateExecutionOracle,
-  artifact: FunctionArtifact,
+  artifact: FunctionArtifactWithContractName,
   contractAddress: AztecAddress,
   functionSelector: FunctionSelector,
   log = createLogger('simulator:private_execution'),
 ): Promise<PrivateCallExecutionResult> {
   const functionName = await privateExecutionOracle.getDebugFunctionName();
   log.verbose(`Executing private function ${functionName}`, { contract: contractAddress });
-  const acir = artifact.bytecode;
   const initialWitness = privateExecutionOracle.getInitialWitness(artifact);
   const acvmCallback = new Oracle(privateExecutionOracle);
   const timer = new Timer();
   const acirExecutionResult = await simulator
-    .executeUserCircuit(acir, initialWitness, acvmCallback)
+    .executeUserCircuit(initialWitness, artifact, acvmCallback)
     .catch((err: Error) => {
       err.message = resolveAssertionMessageFromError(err, artifact);
       throw new ExecutionError(
@@ -79,7 +83,7 @@ export async function executePrivateFunction(
   log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
   return new PrivateCallExecutionResult(
-    acir,
+    artifact.bytecode,
     Buffer.from(artifact.verificationKey!, 'base64'),
     partialWitness,
     publicInputs,
@@ -113,7 +117,7 @@ export function extractPrivateCircuitPublicInputs(
     if (returnedField === undefined) {
       throw new Error(`Missing return value for index ${i}`);
     }
-    returnData.push(fromACVMField(returnedField));
+    returnData.push(Fr.fromString(returnedField));
   }
   return PrivateCircuitPublicInputs.fromFields(returnData);
 }

package/src/private/private_execution_oracle.ts

@@ -606,7 +606,11 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
       this.scopes,
     );
     for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
-      await this.executionDataProvider.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
+      await this.executionDataProvider.processTaggedLogs(
+        this.contractAddress,
+        taggedLogs,
+        AztecAddress.fromString(recipient),
+      );
     }
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);

package/src/private/providers/acvm_native.ts

@@ -1,8 +1,10 @@
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { WitnessMap } from '@aztec/noir-acvm_js';
+import type { ForeignCallHandler } from '@aztec/noir-protocol-circuits-types/types';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
@@ -136,12 +138,21 @@ export async function executeNativeCircuit(
 
 export class NativeACVMSimulator implements SimulationProvider {
   constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+
+  async executeProtocolCircuit(
+    input: ACVMWitness,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler | undefined,
+  ): Promise<ACVMWitness> {
     // Execute the circuit on those initial witness values
 
+    if (callback) {
+      throw new Error('Native ACVM simulator does not support foreign calls. Ignoring callback.');
+    }
+
     const operation = async (directory: string) => {
       // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-      const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+      const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
       // Execute the circuit
       const result = await executeNativeCircuit(
         input,
@@ -162,8 +173,8 @@ export class NativeACVMSimulator implements SimulationProvider {
   }
 
   executeUserCircuit(
-    _acir: Buffer,
-    _initialWitness: ACVMWitness,
+    _input: ACVMWitness,
+    _artifact: FunctionArtifactWithContractName,
     _callback: ACIRCallback,
   ): Promise<ACIRExecutionResult> {
     throw new Error('Not implemented');

package/src/private/providers/acvm_wasm.ts

@@ -1,11 +1,10 @@
 import { createLogger } from '@aztec/foundation/log';
-import initACVM, { type ExecutionError, executeCircuit } from '@aztec/noir-acvm_js';
+import initACVM, { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import initAbi from '@aztec/noir-noirc_abi';
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
-import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
-import { type ACIRCallback, acvm } from '../acvm/acvm.js';
+import { type ACIRCallback, type ACIRExecutionResult, acvm } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
 import { type SimulationProvider, enrichNoirError } from './simulation_provider.js';
 
@@ -22,41 +21,49 @@ export class WASMSimulator implements SimulationProvider {
     }
   }
 
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
-    this.log.debug('init', { hash: compiledCircuit.hash });
+  async executeProtocolCircuit(
+    input: ACVMWitness,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler,
+  ): Promise<ACVMWitness> {
+    this.log.debug('init', { hash: artifact.hash });
     await this.init();
-    // Execute the circuit on those initial witness values
-    //
+
     // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+    const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
     //
     // Execute the circuit
     try {
-      const _witnessMap = await executeCircuit(
+      const result = await executeCircuit(
         decodedBytecode,
         input,
-        foreignCallHandler, // handle calls to debug_log
+        callback, // handle calls to debug_log
       );
-      this.log.debug('execution successful', { hash: compiledCircuit.hash });
-      return _witnessMap;
+      this.log.debug('execution successful', { hash: artifact.hash });
+      return result;
     } catch (err) {
-      // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
+      // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
+      // assertion payload.
       if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
-        const parsed = enrichNoirError(compiledCircuit, err as ExecutionError);
+        const parsed = enrichNoirError(artifact, err as ExecutionError);
         this.log.debug('execution failed', {
-          hash: compiledCircuit.hash,
+          hash: artifact.hash,
           error: parsed,
           message: parsed.message,
         });
         throw parsed;
       }
-      this.log.debug('execution failed', { hash: compiledCircuit.hash, error: err });
+      this.log.debug('execution failed', { hash: artifact.hash, error: err });
       throw new Error(`Circuit execution failed: ${err}`);
     }
   }
 
-  async executeUserCircuit(acir: Buffer, initialWitness: ACVMWitness, callback: ACIRCallback) {
+  async executeUserCircuit(
+    input: ACVMWitness,
+    artifact: FunctionArtifactWithContractName,
+    callback: ACIRCallback,
+  ): Promise<ACIRExecutionResult> {
     await this.init();
-    return acvm(acir, initialWitness, callback);
+    return acvm(artifact.bytecode, input, callback);
   }
 }

package/src/private/providers/acvm_wasm_with_blobs.ts

@@ -1,7 +1,7 @@
-import { type ExecutionError, executeCircuit } from '@aztec/noir-acvm_js';
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
+import { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
 import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
@@ -15,33 +15,36 @@ import { type SimulationProvider, enrichNoirError } from './simulation_provider.
  * It is only used in the context of server-side code executing simulated protocol circuits.
  */
 export class WASMSimulatorWithBlobs implements SimulationProvider {
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
-    // Execute the circuit on those initial witness values
-    //
+  async executeProtocolCircuit(
+    input: WitnessMap,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler,
+  ): Promise<WitnessMap> {
     // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+    const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
     //
     // Execute the circuit
     try {
       const _witnessMap = await executeCircuit(
         decodedBytecode,
         input,
-        foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
+        callback, // handle calls to debug_log and evaluate_blobs mock
       );
 
       return _witnessMap;
     } catch (err) {
-      // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
+      // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
+      // assertion payload.
       if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
-        throw enrichNoirError(compiledCircuit, err as ExecutionError);
+        throw enrichNoirError(artifact, err as ExecutionError);
       }
       throw new Error(`Circuit execution failed: ${err}`);
     }
   }
 
   executeUserCircuit(
-    _acir: Buffer,
-    _initialWitness: ACVMWitness,
+    _input: ACVMWitness,
+    _artifact: FunctionArtifactWithContractName,
     _callback: ACIRCallback,
   ): Promise<ACIRExecutionResult> {
     throw new Error('Not implemented');

package/src/private/providers/circuit_recording/circuit_recorder.ts

@@ -0,0 +1,283 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { ForeignCallHandler, ForeignCallInput, ForeignCallOutput } from '@aztec/noir-acvm_js';
+
+import { createHash } from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+
+import type { ACIRCallback } from '../../acvm/acvm.js';
+import type { ACVMWitness } from '../../acvm/acvm_types.js';
+import { Oracle } from '../../acvm/oracle/oracle.js';
+
+/**
+ * Class responsible for recording circuit inputs necessary to replay the circuit. These inputs are the initial witness
+ * map and the oracle calls made during the circuit execution/witness generation.
+ *
+ * The recording is stored in a JSON file called `circuit_name_circuit_function_name_YYYY-MM-DD_N.json` where N is
+ * a counter to ensure unique filenames. The file is stored in the `recordDir` directory provided as a parameter to
+ * CircuitRecorder.start().
+ *
+ * Example recording file:
+ * ```json
+ * {
+ *   "circuitName": "AMM",
+ *   "functionName": "add_liquidity",
+ *   "bytecodeMd5Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
+ *   "timestamp": 1740691464360,
+ *   "inputs": {
+ *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
+ *     "1": "0x00f4d59c0ff773427bb0fed5b422557ca4dc5655abe53d31fa9408cb3c5a672f",
+ *     "5": "0x000000000000000000000000000000000000000000000000000000000000000f"
+ *   },
+ *   "oracleCalls": [
+ *     {
+ *       "name": "loadCapsule",
+ *       "inputs": [
+ *         [
+ *           "0x102422483bad6abd385948435667e144ac4c272576e325e7563608876cd446fd"
+ *         ],
+ *         [
+ *           "0x000000000000000000000000000000000000000000000000000000000000004d"
+ *         ],
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000001"
+ *         ]
+ *       ],
+ *       "outputs": [
+ *         "0x0000000000000000000000000000000000000000000000000000000000000000",
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000000"
+ *         ]
+ *       ]
+ *     },
+ *     {
+ *       "name": "syncNotes",
+ *       "inputs": []
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+export class CircuitRecorder {
+  private readonly logger = createLogger('simulator:acvm:recording');
+  private isFirstCall = true;
+
+  private constructor(private readonly filePath: string) {}
+
+  /**
+   * Initializes a new circuit recording session.
+   * @param recordDir - Directory to store the recording
+   * @param input - Circuit input witness
+   * @param circuitBytecode - Compiled circuit bytecode
+   * @param circuitName - Name of the circuit
+   * @param functionName - Name of the circuit function (defaults to 'main'). This is meaningful only for
+   * contracts as protocol circuits artifacts always contain a single entrypoint function called 'main'.
+   * @returns A new CircuitRecorder instance
+   */
+  static async start(
+    recordDir: string,
+    input: ACVMWitness,
+    circuitBytecode: Buffer,
+    circuitName: string,
+    functionName: string = 'main',
+  ): Promise<CircuitRecorder> {
+    const recording = {
+      circuitName: circuitName,
+      functionName: functionName,
+      bytecodeMd5Hash: createHash('md5').update(circuitBytecode).digest('hex'),
+      timestamp: Date.now(),
+      inputs: Object.fromEntries(input),
+    };
+
+    const recordingStringWithoutClosingBracket = JSON.stringify(recording, null, 2).slice(0, -2);
+
+    try {
+      // Check if the recording directory exists and is a directory
+      const stats = await fs.stat(recordDir);
+      if (!stats.isDirectory()) {
+        throw new Error(`Recording path ${recordDir} exists but is not a directory`);
+      }
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        // The directory does not exist so we create it
+        await fs.mkdir(recordDir, { recursive: true });
+      } else {
+        throw err;
+      }
+    }
+
+    const filePath = await CircuitRecorder.#computeFilePathAndStoreInitialRecording(
+      recordDir,
+      circuitName,
+      functionName,
+      recordingStringWithoutClosingBracket,
+    );
+    return new CircuitRecorder(filePath);
+  }
+
+  /**
+   * Computes a unique file path for the recording by trying different counter values.
+   * This is needed because multiple recordings of the same circuit could be happening simultaneously or an older
+   * recording might be present.
+   * @param recordDir - Directory to store the recording
+   * @param circuitName - Name of the circuit
+   * @param functionName - Name of the circuit function
+   * @param recordingContent - Initial recording content
+   * @returns A unique file path for the recording
+   */
+  static async #computeFilePathAndStoreInitialRecording(
+    recordDir: string,
+    circuitName: string,
+    functionName: string,
+    recordingContent: string,
+  ): Promise<string> {
+    let counter = 0;
+    while (true) {
+      try {
+        const filePath = getFilePath(recordDir, circuitName, functionName, counter);
+        // Write the initial recording content to the file
+        await fs.writeFile(filePath, recordingContent + ',\n  "oracleCalls": [\n', {
+          flag: 'wx', // wx flag fails if file exists
+        });
+        return filePath;
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
+          counter++;
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Wraps a callback to record all oracle/foreign calls.
+   * @param callback - The original callback to wrap, either a user circuit callback or protocol circuit callback.
+   * @returns A wrapped callback that records all oracle interactions.
+   */
+  wrapCallback(callback: ACIRCallback | ForeignCallHandler | undefined): ACIRCallback | ForeignCallHandler | undefined {
+    if (!callback) {
+      return undefined;
+    }
+    if (this.#isACIRCallback(callback)) {
+      return this.#wrapUserCircuitCallback(callback);
+    }
+    return this.#wrapProtocolCircuitCallback(callback);
+  }
+
+  /**
+   * Type guard to check if a callback is an ACIRCallback.
+   */
+  #isACIRCallback(callback: ACIRCallback | ForeignCallHandler): callback is ACIRCallback {
+    return typeof callback === 'object' && callback !== null && !('call' in callback);
+  }
+
+  /**
+   * Wraps a user circuit callback to record all oracle calls.
+   * @param callback - The original circuit callback.
+   * @returns A wrapped callback that records all oracle interactions which is to be provided to the ACVM.
+   */
+  #wrapUserCircuitCallback(callback: ACIRCallback): ACIRCallback {
+    const recordingCallback: ACIRCallback = {} as ACIRCallback;
+    const oracleMethods = Object.getOwnPropertyNames(Oracle.prototype).filter(name => name !== 'constructor');
+
+    for (const name of oracleMethods) {
+      const fn = callback[name as keyof ACIRCallback];
+      if (!fn) {
+        throw new Error(`Oracle method ${name} not found when setting up recording callback`);
+      }
+
+      recordingCallback[name as keyof ACIRCallback] = (...args: ForeignCallInput[]): ReturnType<typeof fn> => {
+        const result = fn.call(callback, ...args);
+        if (result instanceof Promise) {
+          return result.then(async r => {
+            await this.#recordCall(name, args, r);
+            return r;
+          }) as ReturnType<typeof fn>;
+        }
+        void this.#recordCall(name, args, result);
+        return result;
+      };
+    }
+
+    return recordingCallback;
+  }
+
+  /**
+   * Wraps a protocol circuit callback to record all oracle calls.
+   * @param callback - The original oracle circuit callback.
+   * @returns A wrapped handler that records all oracle interactions which is to be provided to the ACVM.
+   */
+  #wrapProtocolCircuitCallback(callback: ForeignCallHandler): ForeignCallHandler {
+    return async (name: string, inputs: ForeignCallInput[]): Promise<ForeignCallOutput[]> => {
+      const result = await callback(name, inputs);
+      await this.#recordCall(name, inputs, result);
+      return result;
+    };
+  }
+
+  /**
+   * Records a single oracle/foreign call with its inputs and outputs.
+   * @param name - Name of the call
+   * @param inputs - Input arguments
+   * @param outputs - Output results
+   */
+  async #recordCall(name: string, inputs: unknown[], outputs: unknown) {
+    try {
+      const entry = {
+        name,
+        inputs,
+        outputs,
+      };
+      const prefix = this.isFirstCall ? '    ' : '    ,';
+      this.isFirstCall = false;
+      await fs.appendFile(this.filePath, prefix + JSON.stringify(entry) + '\n');
+    } catch (err) {
+      this.logger.error('Failed to log circuit call', { error: err });
+    }
+  }
+
+  /**
+   * Finalizes the recording file by adding closing brackets. Without calling this method, the recording file is
+   * incomplete and it fails to parse.
+   */
+  async finish(): Promise<void> {
+    try {
+      await fs.appendFile(this.filePath, '  ]\n}\n');
+    } catch (err) {
+      this.logger.error('Failed to finalize recording file', { error: err });
+    }
+  }
+
+  /**
+   * Finalizes the recording file by adding the error and closing brackets. Without calling this method or `finish`,
+   * the recording file is incomplete and it fails to parse.
+   * @param error - The error that occurred during circuit execution
+   */
+  async finishWithError(error: unknown): Promise<void> {
+    try {
+      await fs.appendFile(this.filePath, '  ],\n');
+      await fs.appendFile(this.filePath, `  "error": ${JSON.stringify(error)}\n`);
+      await fs.appendFile(this.filePath, '}\n');
+    } catch (err) {
+      this.logger.error('Failed to finalize recording file with error', { error: err });
+    }
+  }
+}
+
+/**
+ * Generates a file path for storing circuit recordings. The format of the filename is:
+ * `circuit_name_circuit_function_name_YYYY-MM-DD_N.json` where N is a counter to ensure unique filenames.
+ * @param recordDir - Base directory for recordings
+ * @param circuitName - Name of the circuit
+ * @param functionName - Name of the circuit function
+ * @param counter - Counter to ensure unique filenames. This is expected to be incremented in a loop until there is no
+ * existing file with the same name.
+ * @returns A file path for the recording.
+ */
+function getFilePath(recordDir: string, circuitName: string, functionName: string, counter: number): string {
+  const date = new Date();
+  const formattedDate = date.toISOString().split('T')[0];
+  const filename = `${circuitName}_${functionName}_${formattedDate}_${counter}.json`;
+  return path.join(recordDir, filename);
+}