@aztec/simulator 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.0.1-commit.d3ec352c",
+  "version": "0.0.1-commit.d58ff9d0",
   "type": "module",
   "exports": {
     "./server": "./dest/server.js",
     "./client": "./dest/client.js",
     "./testing": "./dest/testing.js",
-    "./public/fixtures": "./dest/public/fixtures/index.js",
-    "./public/avm/opcodes": "./dest/public/avm/opcodes/index.js"
+    "./public/fixtures": "./dest/public/fixtures/index.js"
   },
   "typedocOptions": {
     "entryPoints": [
@@ -20,8 +19,9 @@
     "build": "yarn clean && ../scripts/tsc.sh",
     "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
+    "generate": "node --experimental-strip-types --experimental-transform-types --no-warnings ../../ipc-codegen/src/generate.ts --schema ../../barretenberg/cpp/src/barretenberg/cdb/cdb_schema.json --lang ts --server --out src/public/cdb/generated",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
-    "build:fuzzer": "tsgo scripts/fuzzing/avm_simulator_bin.ts --outDir dest/scripts/fuzzing --module commonjs --target es2022 --esModuleInterop --allowSyntheticDefaultImports --resolveJsonModule --skipLibCheck"
+    "build:fuzzer": "yarn clean && yarn generate && ../scripts/tsc.sh"
   },
   "inherits": [
     "../package.common.json"
@@ -64,32 +64,35 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.d3ec352c",
-    "@aztec/foundation": "0.0.1-commit.d3ec352c",
-    "@aztec/native": "0.0.1-commit.d3ec352c",
-    "@aztec/noir-acvm_js": "0.0.1-commit.d3ec352c",
-    "@aztec/noir-noirc_abi": "0.0.1-commit.d3ec352c",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.d3ec352c",
-    "@aztec/noir-types": "0.0.1-commit.d3ec352c",
-    "@aztec/protocol-contracts": "0.0.1-commit.d3ec352c",
-    "@aztec/stdlib": "0.0.1-commit.d3ec352c",
-    "@aztec/telemetry-client": "0.0.1-commit.d3ec352c",
-    "@aztec/world-state": "0.0.1-commit.d3ec352c",
+    "@aztec/bb-avm-sim": "0.0.1-commit.d58ff9d0",
+    "@aztec/constants": "0.0.1-commit.d58ff9d0",
+    "@aztec/foundation": "0.0.1-commit.d58ff9d0",
+    "@aztec/ipc-runtime": "0.0.1-commit.d58ff9d0",
+    "@aztec/native": "0.0.1-commit.d58ff9d0",
+    "@aztec/noir-acvm_js": "0.0.1-commit.d58ff9d0",
+    "@aztec/noir-noirc_abi": "0.0.1-commit.d58ff9d0",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.d58ff9d0",
+    "@aztec/noir-types": "0.0.1-commit.d58ff9d0",
+    "@aztec/protocol-contracts": "0.0.1-commit.d58ff9d0",
+    "@aztec/standard-contracts": "0.0.1-commit.d58ff9d0",
+    "@aztec/stdlib": "0.0.1-commit.d58ff9d0",
+    "@aztec/telemetry-client": "0.0.1-commit.d58ff9d0",
+    "@aztec/world-state": "0.0.1-commit.d58ff9d0",
     "lodash.clonedeep": "^4.5.0",
     "lodash.merge": "^4.6.2",
+    "msgpackr": "^1.11.2",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/kv-store": "0.0.1-commit.d3ec352c",
-    "@aztec/merkle-tree": "0.0.1-commit.d3ec352c",
-    "@aztec/noir-contracts.js": "0.0.1-commit.d3ec352c",
-    "@aztec/noir-test-contracts.js": "0.0.1-commit.d3ec352c",
+    "@aztec/kv-store": "0.0.1-commit.d58ff9d0",
+    "@aztec/noir-contracts.js": "0.0.1-commit.d58ff9d0",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.d58ff9d0",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.clonedeep": "^4.5.7",
     "@types/lodash.merge": "^4.6.9",
     "@types/node": "^22.15.17",
-    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "istanbul-lib-hook": "^3.0.0",
     "istanbul-lib-instrument": "^6.0.3",
     "jest": "^30.0.0",

package/src/client.ts

@@ -1,6 +1,4 @@
 export * from './private/acvm/index.js';
 export { WASMSimulator } from './private/acvm_wasm.js';
-export { SimulatorRecorderWrapper } from './private/circuit_recording/simulator_recorder_wrapper.js';
-export { MemoryCircuitRecorder } from './private/circuit_recording/memory_circuit_recorder.js';
 export { type CircuitSimulator, type DecodedError } from './private/circuit_simulator.js';
 export * from './common/index.js';

package/src/common/errors.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { RawAssertionPayload } from '@aztec/noir-acvm_js';
 import { abiDecodeError } from '@aztec/noir-noirc_abi';

package/src/private/acvm/acvm.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 import {
   type ExecutionError,
   type ForeignCallInput,
@@ -37,6 +37,7 @@ export interface ACIRExecutionResult {
  * @param acir - The ACIR circuit bytecode to execute.
  * @param initialWitness - The initial witness map defining all of the inputs to `circuit`.
  * @param callback - A callback to process any foreign calls from the circuit.
+ * @param logger - Optional logger for ACVM execution logs.
  * @returns The solved witness calculated by executing the circuit on the provided inputs, as well as the return
  * witness indices as specified by the circuit.
  */
@@ -44,9 +45,9 @@ export async function acvm(
   acir: Buffer,
   initialWitness: ACVMWitness,
   callback: ACIRCallback,
+  loggerOrBindings?: Logger | LoggerBindings,
 ): Promise<ACIRExecutionResult> {
-  const logger = createLogger('simulator:acvm');
-
+  const logger = resolveLogger('simulator:acvm', loggerOrBindings);
   const solvedAndReturnWitness = await executeCircuitWithReturnWitness(
     acir,
     initialWitness,

package/src/private/acvm/deserialize.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import type { ACVMField, ACVMWitness } from './acvm_types.js';

package/src/private/acvm/serialize.ts

@@ -1,5 +1,5 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
 import type { ACVMField } from './acvm_types.js';

package/src/private/acvm_native.ts

@@ -1,5 +1,5 @@
 import { runInDirectory } from '@aztec/foundation/fs';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { ForeignCallHandler, WitnessMap } from '@aztec/noir-acvm_js';
 import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
@@ -12,8 +12,6 @@ import type { ACIRCallback, ACIRExecutionResult } from './acvm/acvm.js';
 import type { ACVMWitness } from './acvm/acvm_types.js';
 import type { CircuitSimulator } from './circuit_simulator.js';
 
-const logger = createLogger('simulator:acvm-native');
-
 export enum ACVM_RESULT {
   SUCCESS,
   FAILURE,
@@ -64,7 +62,9 @@ export async function executeNativeCircuit(
   workingDirectory: string,
   pathToAcvm: string,
   outputFilename?: string,
+  loggerOrBindings?: Logger | LoggerBindings,
 ): Promise<ACVMResult> {
+  const logger = resolveLogger('simulator:acvm-native', loggerOrBindings);
   const bytecodeFilename = 'bytecode';
   const witnessFilename = 'input_witness.toml';
 
@@ -145,11 +145,16 @@ export async function executeNativeCircuit(
 }
 
 export class NativeACVMSimulator implements CircuitSimulator {
+  private logger: Logger;
+
   constructor(
     private workingDirectory: string,
     private pathToAcvm: string,
     private witnessFilename?: string,
-  ) {}
+    loggerOrBindings?: Logger | LoggerBindings,
+  ) {
+    this.logger = resolveLogger('simulator:acvm-native', loggerOrBindings);
+  }
 
   async executeProtocolCircuit(
     input: ACVMWitness,
@@ -172,6 +177,7 @@ export class NativeACVMSimulator implements CircuitSimulator {
         directory,
         this.pathToAcvm,
         this.witnessFilename,
+        this.logger,
       );
 
       if (result.status == ACVM_RESULT.FAILURE) {
@@ -181,7 +187,7 @@ export class NativeACVMSimulator implements CircuitSimulator {
       return result;
     };
 
-    return await runInDirectory(this.workingDirectory, operation, false, logger);
+    return await runInDirectory(this.workingDirectory, operation, false, this.logger);
   }
 
   executeUserCircuit(

package/src/private/acvm_wasm.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import initACVM, { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import initAbi from '@aztec/noir-noirc_abi';
@@ -10,8 +10,14 @@ import type { ACVMWitness } from './acvm/acvm_types.js';
 import type { ACVMSuccess } from './acvm_native.js';
 import { type CircuitSimulator, enrichNoirError } from './circuit_simulator.js';
 
+let wasmInitPromise: Promise<unknown> | undefined;
+
 export class WASMSimulator implements CircuitSimulator {
-  constructor(protected log = createLogger('wasm-simulator')) {}
+  protected log: Logger;
+
+  constructor(loggerOrBindings?: Logger | LoggerBindings) {
+    this.log = resolveLogger('wasm-simulator', loggerOrBindings);
+  }
 
   async init(): Promise<void> {
     // If these are available, then we are in the
@@ -19,7 +25,8 @@ export class WASMSimulator implements CircuitSimulator {
     // is a no-op.
     if (typeof initAbi === 'function') {
       /** @ts-expect-error The node bundle doesn't include these default imports, so TS complains */
-      await Promise.all([initAbi(), initACVM()]);
+      wasmInitPromise ??= Promise.all([initAbi(), initACVM()]);
+      await wasmInitPromise;
     }
   }
 
@@ -67,6 +74,6 @@ export class WASMSimulator implements CircuitSimulator {
     callback: ACIRCallback,
   ): Promise<ACIRExecutionResult> {
     await this.init();
-    return acvm(artifact.bytecode, input, callback);
+    return acvm(artifact.bytecode, input, callback, this.log.createChild('acvm'));
   }
 }

package/src/private/circuit_recording/circuit_recorder.ts

@@ -1,8 +1,10 @@
-import { sha512 } from '@aztec/foundation/crypto';
-import { createLogger } from '@aztec/foundation/log';
+import { sha512 } from '@aztec/foundation/crypto/sha512';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { ForeignCallHandler, ForeignCallInput, ForeignCallOutput } from '@aztec/noir-acvm_js';
 
+import { AsyncLocalStorage } from 'node:async_hooks';
+
 import type { ACIRCallback } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
 
@@ -43,10 +45,23 @@ export class CircuitRecording {
   }
 }
 
+/** Inputs needed to open a recording for a single circuit execution. */
+export type RecordingMetadata = {
+  input: ACVMWitness;
+  bytecode: Buffer;
+  circuitName: string;
+  functionName: string;
+};
+
 /**
  * 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 active recording for an execution lives in `AsyncLocalStorage`, so each (possibly nested) circuit execution owns
+ * its own recording and concurrent or re-entrant executions cannot corrupt one another's state. Nested executions
+ * (`aztec_prv_callPrivateFunction`, utility calls) re-enter {@link record}, which links the child to the recording
+ * active in the enclosing async context and lets ALS restore the parent automatically when the child completes.
+ *
  * Example recording object:
  * ```json
  * {
@@ -89,37 +104,46 @@ export class CircuitRecording {
  * ```
  */
 export class CircuitRecorder {
-  protected readonly logger = createLogger('simulator:acvm:recording');
+  protected readonly logger: Logger;
 
-  protected recording?: CircuitRecording;
+  readonly #recordings = new AsyncLocalStorage<CircuitRecording>();
 
-  private stackDepth: number = 0;
-  private newCircuit: boolean = true;
-
-  protected constructor() {}
+  protected constructor(loggerOrBindings?: Logger | LoggerBindings) {
+    this.logger = resolveLogger('simulator:acvm:recording', loggerOrBindings);
+  }
 
   /**
-   * 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'.
+   * Records a single circuit execution. Opens a recording for the circuit (linked as a child of the recording active
+   * in the current async context, if any), runs `fn` within that recording's context, and finalizes it. The recording
+   * is returned alongside the result so callers can derive per-circuit stats (e.g. oracle timings).
+   *
+   * Recorder bookkeeping never alters execution: if `fn` throws, the error is attached to the recording and re-thrown
+   * unchanged.
+   * @param metadata - Identifies the circuit and its initial witness.
+   * @param fn - Runs the circuit execution; its oracle calls are recorded into this recording.
    */
-  start(input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName: string): Promise<void> {
-    const parentRef = this.recording;
-    if (this.newCircuit) {
-      this.recording = new CircuitRecording(
-        circuitName,
-        functionName,
-        sha512(circuitBytecode).toString('hex'),
-        Object.fromEntries(input),
-      );
-    }
-    this.recording!.setParent(parentRef);
+  record<T>(metadata: RecordingMetadata, fn: () => Promise<T>): Promise<{ result: T; recording: CircuitRecording }> {
+    const parent = this.#recordings.getStore();
+    const recording = new CircuitRecording(
+      metadata.circuitName,
+      metadata.functionName,
+      sha512(metadata.bytecode).toString('hex'),
+      Object.fromEntries(metadata.input),
+    );
+    recording.setParent(parent);
 
-    return Promise.resolve();
+    return this.#recordings.run(recording, async () => {
+      await this.onStart(recording);
+      try {
+        const result = await fn();
+        await this.onFinish(recording);
+        return { result, recording };
+      } catch (error) {
+        recording.error = JSON.stringify(error);
+        await this.onError(recording, error);
+        throw error;
+      }
+    });
   }
 
   /**
@@ -145,7 +169,9 @@ export class CircuitRecorder {
   }
 
   /**
-   * Wraps a user circuit callback to record all oracle calls.
+   * Wraps a user circuit callback to record all oracle calls. A nested circuit entered via an oracle (e.g.
+   * `aztec_prv_callPrivateFunction`) re-enters {@link record}, so its own oracle calls land on the child recording and
+   * this circuit's calls (including the entering oracle call itself) land on this recording once the child completes.
    * @param callback - The original circuit callback.
    * @returns A wrapped callback that records all oracle interactions which is to be provided to the ACVM.
    */
@@ -159,38 +185,16 @@ export class CircuitRecorder {
         throw new Error(`Oracle method ${name} not found when setting up recording callback`);
       }
 
-      const isExternalCall = (name as keyof ACIRCallback) === 'privateCallPrivateFunction';
-
       recordingCallback[name as keyof ACIRCallback] = (...args: ForeignCallInput[]): ReturnType<typeof fn> => {
         const timer = new Timer();
-        // If we're entering another circuit via `privateCallPrivateFunction`, we increase the stack depth and set the
-        // newCircuit variable to ensure we are creating a new recording object.
-        if (isExternalCall) {
-          this.stackDepth++;
-          this.newCircuit = true;
-        }
         const result = fn.call(callback, ...args);
         if (result instanceof Promise) {
           return result.then(async r => {
-            // Once we leave the nested circuit, we decrease the stack depth and set newCircuit to false
-            // since we are going back to the "parent" circuit which can never be new
-            if (isExternalCall) {
-              this.stackDepth--;
-              this.newCircuit = false;
-              this.recording = this.recording!.parent;
-            }
-            await this.recordCall(name, args, r, timer.ms(), this.stackDepth);
+            await this.recordCall(name, args, r, timer.ms());
             return r;
           }) as ReturnType<typeof fn>;
         }
-        // Once we leave the nested circuit, we decrease the stack depth and set newCircuit to false
-        // since we are going back to the "parent" circuit which can never be new
-        if (isExternalCall) {
-          this.stackDepth--;
-          this.newCircuit = false;
-          this.recording = this.recording!.parent;
-        }
-        void this.recordCall(name, args, result, timer.ms(), this.stackDepth);
+        void this.recordCall(name, args, result, timer.ms());
         return result;
       };
     }
@@ -207,54 +211,59 @@ export class CircuitRecorder {
     return async (name: string, inputs: ForeignCallInput[]): Promise<ForeignCallOutput[]> => {
       const timer = new Timer();
       const result = await callback(name, inputs);
-      await this.recordCall(name, inputs, result, timer.ms(), 0);
+      await this.recordCall(name, inputs, result, timer.ms());
       return result;
     };
   }
 
   /**
-   * Records a single oracle/foreign call with its inputs and outputs.
+   * Records a single oracle/foreign call with its inputs and outputs against the recording active in the current
+   * async context.
    * @param name - Name of the call
    * @param inputs - Input arguments
    * @param outputs - Output results
    */
-  recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number): Promise<OracleCall> {
+  recordCall(name: string, inputs: unknown[], outputs: unknown, time: number): Promise<OracleCall> {
+    const recording = this.#recordings.getStore();
     const entry = {
       name,
       inputs,
       outputs,
       time,
-      stackDepth,
+      stackDepth: depthOf(recording),
     };
-    this.recording!.oracleCalls.push(entry);
+    // Outside any active recording context (e.g. a stray call after the scope closed, or a direct unit-test call)
+    // there is nowhere to record; return the entry without throwing into the execution path.
+    recording?.oracleCalls.push(entry);
     return Promise.resolve(entry);
   }
 
-  /**
-   * Finalizes the recording by resetting the state and returning the recording object.
-   */
-  finish(): Promise<CircuitRecording> {
-    const result = this.recording;
-    // If this is the top-level circuit recording, we reset the state for the next simulator call
-    if (!result!.parent) {
-      this.newCircuit = true;
-      this.recording = undefined;
-    }
-    return Promise.resolve(result!);
+  /** The recording active in the current async context, if any. */
+  protected currentRecording(): CircuitRecording | undefined {
+    return this.#recordings.getStore();
   }
 
-  /**
-   * Finalizes the recording by resetting the state and returning the recording object with an attached error.
-   * @param error - The error that occurred during circuit execution
-   */
-  finishWithError(error: unknown): Promise<CircuitRecording> {
-    const result = this.recording;
-    // If this is the top-level circuit recording, we reset the state for the next simulator call
-    if (!result!.parent) {
-      this.newCircuit = true;
-      this.recording = undefined;
-    }
-    result!.error = JSON.stringify(error);
-    return Promise.resolve(result!);
+  /** Hook invoked when a recording opens, within the recording's context. Overridden to persist recordings. */
+  protected onStart(_recording: CircuitRecording): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Hook invoked when a recording completes successfully, within the recording's context. */
+  protected onFinish(_recording: CircuitRecording): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Hook invoked when a recording's execution throws, within the recording's context. */
+  protected onError(_recording: CircuitRecording, _error: unknown): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+/** Depth of a recording in the call tree: 0 for a top-level circuit, incremented per nested circuit. */
+function depthOf(recording: CircuitRecording | undefined): number {
+  let depth = 0;
+  for (let ancestor = recording?.parent; ancestor; ancestor = ancestor.parent) {
+    depth++;
   }
+  return depth;
 }

package/src/private/circuit_recording/file_circuit_recorder.ts

@@ -1,26 +1,26 @@
+import type { Logger } from '@aztec/foundation/log';
+
 import fs from 'fs/promises';
 import path from 'path';
 
-import type { ACVMWitness } from '../acvm/acvm_types.js';
 import { CircuitRecorder, type CircuitRecording } from './circuit_recorder.js';
 
-export class FileCircuitRecorder extends CircuitRecorder {
-  declare recording?: CircuitRecording & { filePath: string; isFirstCall: boolean };
+/** Per-recording file state, keyed by recording so concurrent/nested executions don't share it. */
+type RecordingFileState = { filePath: string; isFirstCall: boolean };
 
-  constructor(private readonly recordDir: string) {
-    super();
-  }
+export class FileCircuitRecorder extends CircuitRecorder {
+  readonly #fileState = new WeakMap<CircuitRecording, RecordingFileState>();
 
-  override async start(
-    input: ACVMWitness,
-    circuitBytecode: Buffer,
-    circuitName: string,
-    functionName: string = 'main',
+  constructor(
+    private readonly recordDir: string,
+    logger?: Logger,
   ) {
-    await super.start(input, circuitBytecode, circuitName, functionName);
+    super(logger);
+  }
 
+  protected override async onStart(recording: CircuitRecording): Promise<void> {
     const recordingStringWithoutClosingBracket = JSON.stringify(
-      { ...this.recording, isFirstCall: undefined, parent: undefined, oracleCalls: undefined, filePath: undefined },
+      { ...recording, parent: undefined, oracleCalls: undefined },
       null,
       2,
     ).slice(0, -2);
@@ -40,13 +40,13 @@ export class FileCircuitRecorder extends CircuitRecorder {
       }
     }
 
-    this.recording!.isFirstCall = true;
-    this.recording!.filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(
+    const filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(
       this.recordDir,
-      this.recording!.circuitName,
-      this.recording!.functionName,
+      recording.circuitName,
+      recording.functionName,
       recordingStringWithoutClosingBracket,
     );
+    this.#fileState.set(recording, { filePath, isFirstCall: true });
   }
 
   /**
@@ -90,53 +90,48 @@ export class FileCircuitRecorder extends CircuitRecorder {
    * @param inputs - Input arguments
    * @param outputs - Output results
    */
-  override async recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number) {
-    const entry = await super.recordCall(name, inputs, outputs, time, stackDepth);
-    try {
-      const prefix = this.recording!.isFirstCall ? '    ' : '    ,';
-      this.recording!.isFirstCall = false;
-      await fs.appendFile(this.recording!.filePath, prefix + JSON.stringify(entry) + '\n');
-    } catch (err) {
-      this.logger.error('Failed to log circuit call', { error: err });
+  override async recordCall(name: string, inputs: unknown[], outputs: unknown, time: number) {
+    const entry = await super.recordCall(name, inputs, outputs, time);
+    const recording = this.currentRecording();
+    const state = recording && this.#fileState.get(recording);
+    if (state) {
+      try {
+        const prefix = state.isFirstCall ? '    ' : '    ,';
+        state.isFirstCall = false;
+        await fs.appendFile(state.filePath, prefix + JSON.stringify(entry) + '\n');
+      } catch (err) {
+        this.logger.error('Failed to log circuit call', { error: err });
+      }
     }
     return entry;
   }
 
-  /**
-   * Finalizes the recording file by adding closing brackets. Without calling this method, the recording file is
-   * incomplete and it fails to parse.
-   */
-  override async finish(): Promise<CircuitRecording> {
-    // Finish sets the recording to undefined if we are at the topmost circuit,
-    // so we save the current file path before that
-    const filePath = this.recording!.filePath;
-    const result = await super.finish();
+  /** Closes the recording file with the trailing brackets so the JSON parses. */
+  protected override async onFinish(recording: CircuitRecording): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
     try {
-      await fs.appendFile(filePath, '  ]\n}\n');
+      await fs.appendFile(state.filePath, '  ]\n}\n');
     } catch (err) {
       this.logger.error('Failed to finalize recording file', { error: err });
     }
-    return result!;
   }
 
-  /**
-   * 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
-   */
-  override async finishWithError(error: unknown): Promise<CircuitRecording> {
-    // Finish sets the recording to undefined if we are at the topmost circuit,
-    // so we save the current file path before that
-    const filePath = this.recording!.filePath;
-    const result = await super.finishWithError(error);
+  /** Closes the recording file with the execution error and trailing brackets so the JSON parses. */
+  protected override async onError(recording: CircuitRecording, error: unknown): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
     try {
-      await fs.appendFile(filePath, '  ],\n');
-      await fs.appendFile(filePath, `  "error": ${JSON.stringify(error)}\n`);
-      await fs.appendFile(filePath, '}\n');
+      await fs.appendFile(state.filePath, '  ],\n');
+      await fs.appendFile(state.filePath, `  "error": ${JSON.stringify(error)}\n`);
+      await fs.appendFile(state.filePath, '}\n');
     } catch (err) {
       this.logger.error('Failed to finalize recording file with error', { error: err });
     }
-    return result!;
   }
 }
 

package/src/private/circuit_recording/memory_circuit_recorder.ts

@@ -1,11 +1,13 @@
+import type { Logger } from '@aztec/foundation/log';
+
 import { CircuitRecorder } from './circuit_recorder.js';
 
-/*
+/**
  * In memory circuit recorder uses the default implementation. This is kept
- * while we decide the fate of the FileCircuitRecorder
+ * while we decide the fate of the FileCircuitRecorder.
  */
 export class MemoryCircuitRecorder extends CircuitRecorder {
-  constructor() {
-    super();
+  constructor(logger?: Logger) {
+    super(logger);
   }
 }