@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/private/circuit_recording/circuit_recorder.js

@@ -1,6 +1,7 @@
-import { sha512 } from '@aztec/foundation/crypto';
-import { createLogger } from '@aztec/foundation/log';
+import { sha512 } from '@aztec/foundation/crypto/sha512';
+import { resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import { AsyncLocalStorage } from 'node:async_hooks';
 export class CircuitRecording {
     circuitName;
     functionName;
@@ -26,6 +27,11 @@ export class CircuitRecording {
  * 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
  * {
@@ -67,26 +73,39 @@ export class CircuitRecording {
  * }
  * ```
  */ export class CircuitRecorder {
-    logger = createLogger('simulator:acvm:recording');
-    recording;
-    stackDepth = 0;
-    newCircuit = true;
-    constructor(){}
+    logger;
+    #recordings = new AsyncLocalStorage();
+    constructor(loggerOrBindings){
+        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'.
-   */ start(input, circuitBytecode, circuitName, functionName) {
-        const parentRef = this.recording;
-        if (this.newCircuit) {
-            this.recording = new CircuitRecording(circuitName, functionName, sha512(circuitBytecode).toString('hex'), Object.fromEntries(input));
-        }
-        this.recording.setParent(parentRef);
-        return Promise.resolve();
+   * 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.
+   */ record(metadata, fn) {
+        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 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;
+            }
+        });
     }
     /**
    * Wraps a callback to record all oracle/foreign calls.
@@ -107,7 +126,9 @@ export class CircuitRecording {
         return typeof callback === 'object' && callback !== null && !('call' in callback);
     }
     /**
-   * 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.
    */ #wrapUserCircuitCallback(callback) {
@@ -118,37 +139,16 @@ export class CircuitRecording {
             if (!fn || typeof fn !== 'function') {
                 throw new Error(`Oracle method ${name} not found when setting up recording callback`);
             }
-            const isExternalCall = name === 'privateCallPrivateFunction';
             recordingCallback[name] = (...args)=>{
                 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;
                     });
                 }
-                // 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;
             };
         }
@@ -162,48 +162,47 @@ export class CircuitRecording {
         return async (name, inputs)=>{
             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, inputs, outputs, time, stackDepth) {
+   */ recordCall(name, inputs, outputs, time) {
+        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() {
-        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. */ currentRecording() {
+        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) {
-        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. */ onStart(_recording) {
+        return Promise.resolve();
+    }
+    /** Hook invoked when a recording completes successfully, within the recording's context. */ onFinish(_recording) {
+        return Promise.resolve();
+    }
+    /** Hook invoked when a recording's execution throws, within the recording's context. */ onError(_recording, _error) {
+        return Promise.resolve();
+    }
+}
+/** Depth of a recording in the call tree: 0 for a top-level circuit, incremented per nested circuit. */ function depthOf(recording) {
+    let depth = 0;
+    for(let ancestor = recording?.parent; ancestor; ancestor = ancestor.parent){
+        depth++;
     }
+    return depth;
 }

package/dest/private/circuit_recording/file_circuit_recorder.d.ts

@@ -1,31 +1,20 @@
-import type { ACVMWitness } from '../acvm/acvm_types.js';
+import type { Logger } from '@aztec/foundation/log';
 import { CircuitRecorder, type CircuitRecording } from './circuit_recorder.js';
 export declare class FileCircuitRecorder extends CircuitRecorder {
     #private;
     private readonly recordDir;
-    recording?: CircuitRecording & {
-        filePath: string;
-        isFirstCall: boolean;
-    };
-    constructor(recordDir: string);
-    start(input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName?: string): Promise<void>;
+    constructor(recordDir: string, logger?: Logger);
+    protected onStart(recording: CircuitRecording): Promise<void>;
     /**
      * 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
      */
-    recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number): Promise<import("./circuit_recorder.js").OracleCall>;
-    /**
-     * Finalizes the recording file by adding closing brackets. Without calling this method, the recording file is
-     * incomplete and it fails to parse.
-     */
-    finish(): Promise<CircuitRecording>;
-    /**
-     * 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
-     */
-    finishWithError(error: unknown): Promise<CircuitRecording>;
+    recordCall(name: string, inputs: unknown[], outputs: unknown, time: number): Promise<import("./circuit_recorder.js").OracleCall>;
+    /** Closes the recording file with the trailing brackets so the JSON parses. */
+    protected onFinish(recording: CircuitRecording): Promise<void>;
+    /** Closes the recording file with the execution error and trailing brackets so the JSON parses. */
+    protected onError(recording: CircuitRecording, error: unknown): Promise<void>;
 }
-//# sourceMappingURL=file_circuit_recorder.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZV9jaXJjdWl0X3JlY29yZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJpdmF0ZS9jaXJjdWl0X3JlY29yZGluZy9maWxlX2NpcmN1aXRfcmVjb3JkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFLcEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLGdCQUFnQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFLL0UscUJBQWEsbUJBQW9CLFNBQVEsZUFBZTs7SUFJcEQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTO0lBRDVCLFlBQ21CLFNBQVMsRUFBRSxNQUFNLEVBQ2xDLE1BQU0sQ0FBQyxFQUFFLE1BQU0sRUFHaEI7SUFFRCxVQUF5QixPQUFPLENBQUMsU0FBUyxFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E2QjNFO0lBcUNEOzs7OztPQUtHO0lBQ1ksVUFBVSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sdURBY3hGO0lBRUQsK0VBQStFO0lBQy9FLFVBQXlCLFFBQVEsQ0FBQyxTQUFTLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVU1RTtJQUVELG1HQUFtRztJQUNuRyxVQUF5QixPQUFPLENBQUMsU0FBUyxFQUFFLGdCQUFnQixFQUFFLEtBQUssRUFBRSxPQUFPLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVkzRjtDQUNGIn0=

package/dest/private/circuit_recording/file_circuit_recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file_circuit_recorder.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/file_circuit_recorder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,qBAAa,mBAAoB,SAAQ,eAAe;;IAG1C,OAAO,CAAC,QAAQ,CAAC,SAAS;IAF9B,SAAS,CAAC,EAAE,gBAAgB,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC;gBAErD,SAAS,EAAE,MAAM;IAI/B,KAAK,CAClB,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,YAAY,GAAE,MAAe;IAqE/B;;;;;OAKG;IACY,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAY7G;;;OAGG;IACY,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAalD;;;;OAIG;IACY,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAc1E"}
+{"version":3,"file":"file_circuit_recorder.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/file_circuit_recorder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAKpD,OAAO,EAAE,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAK/E,qBAAa,mBAAoB,SAAQ,eAAe;;IAIpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAD5B,YACmB,SAAS,EAAE,MAAM,EAClC,MAAM,CAAC,EAAE,MAAM,EAGhB;IAED,UAAyB,OAAO,CAAC,SAAS,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B3E;IAqCD;;;;;OAKG;IACY,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,uDAcxF;IAED,+EAA+E;IAC/E,UAAyB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAU5E;IAED,mGAAmG;IACnG,UAAyB,OAAO,CAAC,SAAS,EAAE,gBAAgB,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3F;CACF"}

package/dest/private/circuit_recording/file_circuit_recorder.js

@@ -3,17 +3,15 @@ import path from 'path';
 import { CircuitRecorder } from './circuit_recorder.js';
 export class FileCircuitRecorder extends CircuitRecorder {
     recordDir;
-    constructor(recordDir){
-        super(), this.recordDir = recordDir;
+    #fileState;
+    constructor(recordDir, logger){
+        super(logger), this.recordDir = recordDir, this.#fileState = new WeakMap();
     }
-    async start(input, circuitBytecode, circuitName, functionName = 'main') {
-        await super.start(input, circuitBytecode, circuitName, functionName);
+    async onStart(recording) {
         const recordingStringWithoutClosingBracket = JSON.stringify({
-            ...this.recording,
-            isFirstCall: undefined,
+            ...recording,
             parent: undefined,
-            oracleCalls: undefined,
-            filePath: undefined
+            oracleCalls: undefined
         }, null, 2).slice(0, -2);
         try {
             // Check if the recording directory exists and is a directory
@@ -31,8 +29,11 @@ export class FileCircuitRecorder extends CircuitRecorder {
                 throw err;
             }
         }
-        this.recording.isFirstCall = true;
-        this.recording.filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(this.recordDir, this.recording.circuitName, this.recording.functionName, recordingStringWithoutClosingBracket);
+        const filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(this.recordDir, recording.circuitName, recording.functionName, recordingStringWithoutClosingBracket);
+        this.#fileState.set(recording, {
+            filePath,
+            isFirstCall: true
+        });
     }
     /**
    * Computes a unique file path for the recording by trying different counter values.
@@ -67,55 +68,50 @@ export class FileCircuitRecorder extends CircuitRecorder {
    * @param name - Name of the call
    * @param inputs - Input arguments
    * @param outputs - Output results
-   */ async recordCall(name, inputs, outputs, time, stackDepth) {
-        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
-            });
+   */ async recordCall(name, inputs, outputs, time) {
+        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.
-   */ async finish() {
-        // 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. */ async onFinish(recording) {
+        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
-   */ async finishWithError(error) {
-        // 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. */ async onError(recording, error) {
+        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/dest/private/circuit_recording/memory_circuit_recorder.d.ts

@@ -1,5 +1,10 @@
+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.
+ */
 export declare class MemoryCircuitRecorder extends CircuitRecorder {
-    constructor();
+    constructor(logger?: Logger);
 }
-//# sourceMappingURL=memory_circuit_recorder.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb3J5X2NpcmN1aXRfcmVjb3JkZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlL2NpcmN1aXRfcmVjb3JkaW5nL21lbW9yeV9jaXJjdWl0X3JlY29yZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXBELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV4RDs7O0dBR0c7QUFDSCxxQkFBYSxxQkFBc0IsU0FBUSxlQUFlO0lBQ3hELFlBQVksTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUUxQjtDQUNGIn0=

package/dest/private/circuit_recording/memory_circuit_recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory_circuit_recorder.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/memory_circuit_recorder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAMxD,qBAAa,qBAAsB,SAAQ,eAAe;;CAIzD"}
+{"version":3,"file":"memory_circuit_recorder.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/memory_circuit_recorder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,eAAe;IACxD,YAAY,MAAM,CAAC,EAAE,MAAM,EAE1B;CACF"}

package/dest/private/circuit_recording/memory_circuit_recorder.js

@@ -1,9 +1,9 @@
 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){
+        super(logger);
     }
 }

package/dest/private/circuit_recording/simulator_recorder_wrapper.d.ts

@@ -18,4 +18,4 @@ export declare class SimulatorRecorderWrapper implements CircuitSimulator {
     executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler | undefined): Promise<ACVMSuccess>;
     executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
 }
-//# sourceMappingURL=simulator_recorder_wrapper.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltdWxhdG9yX3JlY29yZGVyX3dyYXBwZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlL2NpcmN1aXRfcmVjb3JkaW5nL3NpbXVsYXRvcl9yZWNvcmRlcl93cmFwcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDOUQsT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMxRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXRFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBcUIsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUM1RixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTdEOzs7R0FHRztBQUNILHFCQUFhLHdCQUF5QixZQUFXLGdCQUFnQjs7SUFFN0QsT0FBTyxDQUFDLFNBQVM7SUFDakIsT0FBTyxDQUFDLFFBQVE7SUFGbEIsWUFDVSxTQUFTLEVBQUUsZ0JBQWdCLEVBQzNCLFFBQVEsRUFBRSxlQUFlLEVBQy9CO0lBRUosc0JBQXNCLENBQ3BCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLFFBQVEsRUFBRSwyQkFBMkIsRUFDckMsUUFBUSxFQUFFLGtCQUFrQixHQUFHLFNBQVMsR0FDdkMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQVd0QjtJQUVELGtCQUFrQixDQUNoQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsZ0NBQWdDLEVBQzFDLFFBQVEsRUFBRSxZQUFZLEdBQ3JCLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQVM5QjtDQWtDRiJ9

package/dest/private/circuit_recording/simulator_recorder_wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simulator_recorder_wrapper.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/simulator_recorder_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAqB,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC5F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,gBAAgB;;IAE7D,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;gBADR,SAAS,EAAE,gBAAgB,EAC3B,QAAQ,EAAE,eAAe;IAGnC,sBAAsB,CACpB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC;IAavB,kBAAkB,CAChB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC;CAiDhC"}
+{"version":3,"file":"simulator_recorder_wrapper.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/simulator_recorder_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAqB,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC5F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;GAGG;AACH,qBAAa,wBAAyB,YAAW,gBAAgB;;IAE7D,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ;IAFlB,YACU,SAAS,EAAE,gBAAgB,EAC3B,QAAQ,EAAE,eAAe,EAC/B;IAEJ,sBAAsB,CACpB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC,CAWtB;IAED,kBAAkB,CAChB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAS9B;CAkCF"}

package/dest/private/circuit_recording/simulator_recorder_wrapper.js

@@ -16,21 +16,18 @@
         return this.#simulate((wrappedCallback)=>this.simulator.executeUserCircuit(input, artifact, wrappedCallback), input, artifact.bytecode, artifact.contractName, artifact.name, callback);
     }
     async #simulate(simulateFn, input, bytecode, contractName, functionName, callback) {
-        // Start recording circuit execution
-        await this.recorder.start(input, bytecode, contractName, functionName);
-        // If callback was provided, we wrap it in a circuit recorder callback wrapper
+        // If a callback was provided, we wrap it so that its oracle calls are recorded. The wrapped callback reads the
+        // active recording lazily, so it picks up the recording opened by record() below.
         const wrappedCallback = this.recorder.wrapCallback(callback);
-        let result;
-        try {
-            result = await simulateFn(wrappedCallback);
-        } catch (error) {
-            // If an error occurs, we finalize the recording file with the error
-            await this.recorder.finishWithError(error);
-            throw error;
-        }
-        // Witness generation is complete so we finish the circuit recorder
-        const recording = await this.recorder.finish();
-        result.oracles = recording.oracleCalls?.reduce((acc, { time, name })=>{
+        // record() opens a recording for this circuit, runs the simulation within it, and finalizes it. A simulation
+        // failure is re-thrown unchanged, so recorder bookkeeping never masks the underlying error.
+        const { result, recording } = await this.recorder.record({
+            input,
+            bytecode,
+            circuitName: contractName,
+            functionName
+        }, ()=>simulateFn(wrappedCallback));
+        result.oracles = recording.oracleCalls.reduce((acc, { time, name })=>{
             if (!acc[name]) {
                 acc[name] = {
                     times: []

package/dest/private/circuit_simulator.d.ts

@@ -32,4 +32,4 @@ export type DecodedError = ExecutionError & {
     noirCallStack?: string[];
 };
 export declare function enrichNoirError(artifact: NoirCompiledCircuit, originalError: ExecutionError): DecodedError;
-//# sourceMappingURL=circuit_simulator.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2lyY3VpdF9zaW11bGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlL2NpcmN1aXRfc2ltdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRzlFLE9BQU8sS0FBSyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUzRixPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQUUsS0FBSyxtQkFBbUIsRUFBb0IsTUFBTSxnQkFBZ0IsQ0FBQztBQUMvRixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVwRDs7R0FFRztBQUNILE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0I7Ozs7Ozs7T0FPRztJQUNILHNCQUFzQixDQUNwQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FBRyxTQUFTLEdBQ3ZDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUV4Qjs7Ozs7OztPQU9HO0lBQ0gsa0JBQWtCLENBQ2hCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLFFBQVEsRUFBRSxnQ0FBZ0MsRUFDMUMsUUFBUSxFQUFFLFlBQVksR0FDckIsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUM7Q0FDakM7QUFFRCxNQUFNLE1BQU0sWUFBWSxHQUFHLGNBQWMsR0FBRztJQUFFLHVCQUF1QixDQUFDLEVBQUUsR0FBRyxDQUFDO0lBQUMsYUFBYSxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUE7Q0FBRSxDQUFDO0FBSXhHLHdCQUFnQixlQUFlLENBQUMsUUFBUSxFQUFFLG1CQUFtQixFQUFFLGFBQWEsRUFBRSxjQUFjLEdBQUcsWUFBWSxDQTBDMUcifQ==

package/dest/private/factory.d.ts

@@ -1,4 +1,4 @@
-import { type Logger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
 import type { CircuitSimulator } from './circuit_simulator.js';
 export type SimulatorConfig = {
     acvmBinaryPath?: string;
@@ -8,5 +8,5 @@ export declare function getSimulatorConfigFromEnv(): {
     acvmWorkingDirectory: string | undefined;
     acvmBinaryPath: string | undefined;
 };
-export declare function createSimulator(config: SimulatorConfig, logger?: Logger): Promise<CircuitSimulator>;
-//# sourceMappingURL=factory.d.ts.map
+export declare function createSimulator(config: SimulatorConfig, loggerOrBindings?: Logger | LoggerBindings): Promise<CircuitSimulator>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ByaXZhdGUvZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQUUsS0FBSyxjQUFjLEVBQWlCLE1BQU0sdUJBQXVCLENBQUM7QUFNeEYsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUvRCxNQUFNLE1BQU0sZUFBZSxHQUFHO0lBQzVCLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN4QixvQkFBb0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUMvQixDQUFDO0FBRUYsd0JBQWdCLHlCQUF5Qjs7O0VBTXhDO0FBRUQsd0JBQXNCLGVBQWUsQ0FDbkMsTUFBTSxFQUFFLGVBQWUsRUFDdkIsZ0JBQWdCLENBQUMsRUFBRSxNQUFNLEdBQUcsY0FBYyxHQUN6QyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FnQjNCIn0=

package/dest/private/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/private/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAMlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAgB,yBAAyB;;;EAMxC;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,eAAe,EACvB,MAAM,GAAE,MAAkC,GACzC,OAAO,CAAC,gBAAgB,CAAC,CAa3B"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/private/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAiB,MAAM,uBAAuB,CAAC;AAMxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAgB,yBAAyB;;;EAMxC;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,eAAe,EACvB,gBAAgB,CAAC,EAAE,MAAM,GAAG,cAAc,GACzC,OAAO,CAAC,gBAAgB,CAAC,CAgB3B"}

package/dest/private/factory.js

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { resolveLogger } from '@aztec/foundation/log';
 import { promises as fs } from 'fs';
 import { NativeACVMSimulator } from './acvm_native.js';
 import { WASMSimulator } from './acvm_wasm.js';
@@ -9,7 +9,8 @@ export function getSimulatorConfigFromEnv() {
         acvmBinaryPath: ACVM_BINARY_PATH ? ACVM_BINARY_PATH : undefined
     };
 }
-export async function createSimulator(config, logger = createLogger('simulator')) {
+export async function createSimulator(config, loggerOrBindings) {
+    const logger = resolveLogger('simulator', loggerOrBindings);
     if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
         try {
             await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
@@ -17,11 +18,13 @@ export async function createSimulator(config, logger = createLogger('simulator')
                 recursive: true
             });
             logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
-            return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+            const acvmLogger = logger.createChild('acvm-native');
+            return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, acvmLogger);
         } catch  {
             logger.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
         }
     }
     logger.info('Using WASM ACVM simulation');
-    return new WASMSimulator();
+    const wasmLogger = logger.createChild('wasm');
+    return new WASMSimulator(wasmLogger);
 }

package/dest/public/avm/testing/account_proof_fetcher.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9wcm9vZl9mZXRjaGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcHVibGljL2F2bS90ZXN0aW5nL2FjY291bnRfcHJvb2ZfZmV0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/public/avm/testing/account_proof_fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account_proof_fetcher.d.ts","sourceRoot":"","sources":["../../../../src/public/avm/testing/account_proof_fetcher.ts"],"names":[],"mappings":""}