@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/dest/private/circuit_recording/circuit_recorder.js

@@ -0,0 +1,212 @@
+import { sha512 } from '@aztec/foundation/crypto/sha512';
+import { resolveLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+export class CircuitRecording {
+    circuitName;
+    functionName;
+    bytecodeSHA512Hash;
+    timestamp;
+    inputs;
+    oracleCalls;
+    error;
+    parent;
+    constructor(circuitName, functionName, bytecodeSHA512Hash, inputs){
+        this.circuitName = circuitName;
+        this.functionName = functionName;
+        this.bytecodeSHA512Hash = bytecodeSHA512Hash;
+        this.timestamp = Date.now();
+        this.inputs = inputs;
+        this.oracleCalls = [];
+    }
+    setParent(recording) {
+        this.parent = recording;
+    }
+}
+/**
+ * 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.
+ *
+ * Example recording object:
+ * ```json
+ * {
+ *   "circuitName": "AMM",
+ *   "functionName": "add_liquidity",
+ *   "bytecodeSHA512Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
+ *   "timestamp": 1740691464360,
+ *   "inputs": {
+ *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
+ *     "1": "0x00f4d59c0ff773427bb0fed5b422557ca4dc5655abe53d31fa9408cb3c5a672f",
+ *     "5": "0x000000000000000000000000000000000000000000000000000000000000000f"
+ *   },
+ *   "oracleCalls": [
+ *     {
+ *       "name": "loadCapsule",
+ *       "inputs": [
+ *         [
+ *           "0x102422483bad6abd385948435667e144ac4c272576e325e7563608876cd446fd"
+ *         ],
+ *         [
+ *           "0x000000000000000000000000000000000000000000000000000000000000004d"
+ *         ],
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000001"
+ *         ]
+ *       ],
+ *       "outputs": [
+ *         "0x0000000000000000000000000000000000000000000000000000000000000000",
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000000"
+ *         ]
+ *       ]
+ *     },
+ *     {
+ *       "name": "fetchTaggedLogs",
+ *       "inputs": []
+ *     }
+ *   ]
+ * }
+ * ```
+ */ export class CircuitRecorder {
+    logger;
+    recording;
+    stackDepth = 0;
+    newCircuit = true;
+    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) {
+        if (this.newCircuit) {
+            const parentRef = this.recording;
+            this.recording = new CircuitRecording(circuitName, functionName, sha512(circuitBytecode).toString('hex'), Object.fromEntries(input));
+            this.recording.setParent(parentRef);
+        }
+        return Promise.resolve();
+    }
+    /**
+   * 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) {
+        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) {
+        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) {
+        const recordingCallback = {};
+        const oracleMethods = Object.keys(callback);
+        for (const name of oracleMethods){
+            const fn = callback[name];
+            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
+                        // so that the parent circuit continues with its existing recording
+                        // Note: recording restoration is handled by finish()
+                        if (isExternalCall) {
+                            this.stackDepth--;
+                            this.newCircuit = false;
+                        }
+                        await this.recordCall(name, args, r, timer.ms(), this.stackDepth);
+                        return r;
+                    });
+                }
+                // Once we leave the nested circuit, we decrease the stack depth and set newCircuit to false
+                // so that the parent circuit continues with its existing recording
+                // Note: recording restoration is handled by finish()
+                if (isExternalCall) {
+                    this.stackDepth--;
+                    this.newCircuit = false;
+                }
+                void this.recordCall(name, args, result, timer.ms(), this.stackDepth);
+                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) {
+        return async (name, inputs)=>{
+            const timer = new Timer();
+            const result = await callback(name, inputs);
+            await this.recordCall(name, inputs, result, timer.ms(), 0);
+            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
+   */ recordCall(name, inputs, outputs, time, stackDepth) {
+        const entry = {
+            name,
+            inputs,
+            outputs,
+            time,
+            stackDepth
+        };
+        this.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;
+        } else {
+            // For nested circuits (utility calls, nested contract calls), restore to parent recording
+            // Note: we don't set newCircuit=false here because:
+            // - For privateCallPrivateFunction, the callback wrapper will set it to false
+            // - For utility calls, we want newCircuit to remain true so the next circuit creates its own recording
+            this.recording = result.parent;
+        }
+        return Promise.resolve(result);
+    }
+    /**
+   * 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
+   */ async finishWithError(error) {
+        const result = await this.finish();
+        result.error = JSON.stringify(error);
+        return result;
+    }
+}

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

@@ -0,0 +1,32 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
+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, logger?: Logger);
+    start(input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName?: string): 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>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZV9jaXJjdWl0X3JlY29yZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJpdmF0ZS9jaXJjdWl0X3JlY29yZGluZy9maWxlX2NpcmN1aXRfcmVjb3JkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFLcEQsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDekQsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLGdCQUFnQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFL0UscUJBQWEsbUJBQW9CLFNBQVEsZUFBZTs7SUFJcEQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTO0lBSHBCLFNBQVMsQ0FBQyxFQUFFLGdCQUFnQixHQUFHO1FBQUUsUUFBUSxFQUFFLE1BQU0sQ0FBQztRQUFDLFdBQVcsRUFBRSxPQUFPLENBQUE7S0FBRSxDQUFDO0lBRWxGLFlBQ21CLFNBQVMsRUFBRSxNQUFNLEVBQ2xDLE1BQU0sQ0FBQyxFQUFFLE1BQU0sRUFHaEI7SUFFYyxLQUFLLENBQ2xCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLGVBQWUsRUFBRSxNQUFNLEVBQ3ZCLFdBQVcsRUFBRSxNQUFNLEVBQ25CLFlBQVksR0FBRSxNQUFlLGlCQWdDOUI7SUFxQ0Q7Ozs7O09BS0c7SUFDWSxVQUFVLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLHVEQVU1RztJQUVEOzs7T0FHRztJQUNZLE1BQU0sSUFBSSxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FXakQ7SUFFRDs7OztPQUlHO0lBQ1ksZUFBZSxDQUFDLEtBQUssRUFBRSxPQUFPLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBYXhFO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"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,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,qBAAa,mBAAoB,SAAQ,eAAe;;IAIpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAHpB,SAAS,CAAC,EAAE,gBAAgB,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC;IAElF,YACmB,SAAS,EAAE,MAAM,EAClC,MAAM,CAAC,EAAE,MAAM,EAGhB;IAEc,KAAK,CAClB,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,YAAY,GAAE,MAAe,iBAgC9B;IAqCD;;;;;OAKG;IACY,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,uDAU5G;IAED;;;OAGG;IACY,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAWjD;IAED;;;;OAIG;IACY,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAaxE;CACF"}

package/dest/private/circuit_recording/file_circuit_recorder.js

@@ -0,0 +1,135 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { CircuitRecorder } from './circuit_recorder.js';
+export class FileCircuitRecorder extends CircuitRecorder {
+    recordDir;
+    constructor(recordDir, logger){
+        super(logger), this.recordDir = recordDir;
+    }
+    async start(input, circuitBytecode, circuitName, functionName = 'main') {
+        await super.start(input, circuitBytecode, circuitName, functionName);
+        const recordingStringWithoutClosingBracket = JSON.stringify({
+            ...this.recording,
+            isFirstCall: undefined,
+            parent: undefined,
+            oracleCalls: undefined,
+            filePath: undefined
+        }, null, 2).slice(0, -2);
+        try {
+            // Check if the recording directory exists and is a directory
+            const stats = await fs.stat(this.recordDir);
+            if (!stats.isDirectory()) {
+                throw new Error(`Recording path ${this.recordDir} exists but is not a directory`);
+            }
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                // The directory does not exist so we create it
+                await fs.mkdir(this.recordDir, {
+                    recursive: true
+                });
+            } else {
+                throw err;
+            }
+        }
+        this.recording.isFirstCall = true;
+        this.recording.filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(this.recordDir, this.recording.circuitName, this.recording.functionName, recordingStringWithoutClosingBracket);
+    }
+    /**
+   * 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, circuitName, functionName, recordingContent) {
+        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'
+                });
+                return filePath;
+            } catch (err) {
+                if (err.code === 'EEXIST') {
+                    counter++;
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    /**
+   * 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, 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
+            });
+        }
+        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();
+        try {
+            await fs.appendFile(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);
+        try {
+            await fs.appendFile(filePath, '  ],\n');
+            await fs.appendFile(filePath, `  "error": ${JSON.stringify(error)}\n`);
+            await fs.appendFile(filePath, '}\n');
+        } catch (err) {
+            this.logger.error('Failed to finalize recording file with error', {
+                error: err
+            });
+        }
+        return result;
+    }
+}
+/**
+ * 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, circuitName, functionName, counter) {
+    const date = new Date();
+    const formattedDate = date.toISOString().split('T')[0];
+    const filename = `${circuitName}_${functionName}_${formattedDate}_${counter}.json`;
+    return path.join(recordDir, filename);
+}

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

@@ -0,0 +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(logger?: Logger);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb3J5X2NpcmN1aXRfcmVjb3JkZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlL2NpcmN1aXRfcmVjb3JkaW5nL21lbW9yeV9jaXJjdWl0X3JlY29yZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXBELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV4RDs7O0dBR0c7QUFDSCxxQkFBYSxxQkFBc0IsU0FBUSxlQUFlO0lBQ3hELFlBQVksTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUUxQjtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +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.
+ */ export class MemoryCircuitRecorder extends CircuitRecorder {
+    constructor(logger){
+        super(logger);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { ForeignCallHandler } from '@aztec/noir-acvm_js';
+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';
+import type { ACVMSuccess } from '../acvm_native.js';
+import type { CircuitSimulator } from '../circuit_simulator.js';
+import type { CircuitRecorder } from './circuit_recorder.js';
+/**
+ * Takes a circuit simulator and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
+ * recording works.
+ */
+export declare class SimulatorRecorderWrapper implements CircuitSimulator {
+    #private;
+    private simulator;
+    private recorder;
+    constructor(simulator: CircuitSimulator, recorder: CircuitRecorder);
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler | undefined): Promise<ACVMSuccess>;
+    executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltdWxhdG9yX3JlY29yZGVyX3dyYXBwZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcml2YXRlL2NpcmN1aXRfcmVjb3JkaW5nL3NpbXVsYXRvcl9yZWNvcmRlcl93cmFwcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDOUQsT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUMxRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXRFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBcUIsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUM1RixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTdEOzs7R0FHRztBQUNILHFCQUFhLHdCQUF5QixZQUFXLGdCQUFnQjs7SUFFN0QsT0FBTyxDQUFDLFNBQVM7SUFDakIsT0FBTyxDQUFDLFFBQVE7SUFGbEIsWUFDVSxTQUFTLEVBQUUsZ0JBQWdCLEVBQzNCLFFBQVEsRUFBRSxlQUFlLEVBQy9CO0lBRUosc0JBQXNCLENBQ3BCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLFFBQVEsRUFBRSwyQkFBMkIsRUFDckMsUUFBUSxFQUFFLGtCQUFrQixHQUFHLFNBQVMsR0FDdkMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQVd0QjtJQUVELGtCQUFrQixDQUNoQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsZ0NBQWdDLEVBQzFDLFFBQVEsRUFBRSxZQUFZLEdBQ3JCLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQVM5QjtDQXdDRiJ9

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

@@ -0,0 +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;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;CAwCF"}

package/dest/private/circuit_recording/simulator_recorder_wrapper.js

@@ -0,0 +1,44 @@
+/**
+ * Takes a circuit simulator and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
+ * recording works.
+ */ export class SimulatorRecorderWrapper {
+    simulator;
+    recorder;
+    constructor(simulator, recorder){
+        this.simulator = simulator;
+        this.recorder = recorder;
+    }
+    executeProtocolCircuit(input, artifact, callback) {
+        const bytecode = Buffer.from(artifact.bytecode, 'base64');
+        return this.#simulate((wrappedCallback)=>this.simulator.executeProtocolCircuit(input, artifact, wrappedCallback), input, bytecode, artifact.name, 'main', callback);
+    }
+    executeUserCircuit(input, artifact, callback) {
+        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
+        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 })=>{
+            if (!acc[name]) {
+                acc[name] = {
+                    times: []
+                };
+            }
+            acc[name].times.push(time);
+            return acc;
+        }, {});
+        return result;
+    }
+}

package/dest/private/circuit_simulator.d.ts

@@ -0,0 +1,35 @@
+import type { ExecutionError, ForeignCallHandler } from '@aztec/noir-acvm_js';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuit, NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
+import { type ACIRCallback, type ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
+/**
+ * Low level simulation interface
+ */
+export interface CircuitSimulator {
+    /**
+     * Execute a protocol circuit/generate a witness
+     * @param input - The initial witness map defining all of the inputs to `circuit`.
+     * @param artifact - ACIR circuit bytecode and its metadata.
+     * @param callback - A callback to process any foreign calls from the circuit. Can be undefined as for native
+     * ACVM simulator we don't process foreign calls.
+     * @returns The solved witness calculated by executing the circuit on the provided inputs.
+     */
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler | undefined): Promise<ACVMSuccess>;
+    /**
+     * Execute a user circuit (smart contract function)/generate a witness
+     * @param input - The initial witness map defining all of the inputs to `circuit`.
+     * @param artifact - Contract function ACIR circuit bytecode and its metadata.
+     * @param callback - A callback to process any foreign calls from the circuit.
+     * @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.
+     */
+    executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+export type DecodedError = ExecutionError & {
+    decodedAssertionPayload?: any;
+    noirCallStack?: string[];
+};
+export declare function enrichNoirError(artifact: NoirCompiledCircuit, originalError: ExecutionError): DecodedError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2lyY3VpdF9zaW11bGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcml2YXRlL2NpcmN1aXRfc2ltdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRzlFLE9BQU8sS0FBSyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUUsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUzRixPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQUUsS0FBSyxtQkFBbUIsRUFBb0IsTUFBTSxnQkFBZ0IsQ0FBQztBQUMvRixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVwRDs7R0FFRztBQUNILE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0I7Ozs7Ozs7T0FPRztJQUNILHNCQUFzQixDQUNwQixLQUFLLEVBQUUsV0FBVyxFQUNsQixRQUFRLEVBQUUsMkJBQTJCLEVBQ3JDLFFBQVEsRUFBRSxrQkFBa0IsR0FBRyxTQUFTLEdBQ3ZDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUV4Qjs7Ozs7OztPQU9HO0lBQ0gsa0JBQWtCLENBQ2hCLEtBQUssRUFBRSxXQUFXLEVBQ2xCLFFBQVEsRUFBRSxnQ0FBZ0MsRUFDMUMsUUFBUSxFQUFFLFlBQVksR0FDckIsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUM7Q0FDakM7QUFFRCxNQUFNLE1BQU0sWUFBWSxHQUFHLGNBQWMsR0FBRztJQUFFLHVCQUF1QixDQUFDLEVBQUUsR0FBRyxDQUFDO0lBQUMsYUFBYSxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUE7Q0FBRSxDQUFDO0FBSXhHLHdCQUFnQixlQUFlLENBQUMsUUFBUSxFQUFFLG1CQUFtQixFQUFFLGFBQWEsRUFBRSxjQUFjLEdBQUcsWUFBWSxDQTBDMUcifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"circuit_simulator.d.ts","sourceRoot":"","sources":["../../src/private/circuit_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9E,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAE3F,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAoB,MAAM,gBAAgB,CAAC;AAC/F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;OAOG;IACH,sBAAsB,CACpB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC,CAAC;IAExB;;;;;;;OAOG;IACH,kBAAkB,CAChB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACjC;AAED,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG;IAAE,uBAAuB,CAAC,EAAE,GAAG,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAIxG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,mBAAmB,EAAE,aAAa,EAAE,cAAc,GAAG,YAAY,CA0C1G"}

package/dest/private/circuit_simulator.js

@@ -0,0 +1,43 @@
+import { abiDecodeError } from '@aztec/noir-noirc_abi';
+import { parseDebugSymbols } from '@aztec/stdlib/abi';
+import { extractCallStack } from './acvm/acvm.js';
+// Payload parsing taken from noir/noir-repo/tooling/noir_js/src/witness_generation.ts.
+// TODO: import this in isolation without having to import noir_js in its entirety.
+export function enrichNoirError(artifact, originalError) {
+    const enrichedError = originalError;
+    if (originalError.rawAssertionPayload) {
+        try {
+            // Decode the payload
+            const decodedPayload = abiDecodeError(artifact.abi, originalError.rawAssertionPayload);
+            if (typeof decodedPayload === 'string') {
+                // If it's a string, just add it to the error message
+                enrichedError.message = `Circuit execution failed: ${decodedPayload}`;
+            } else {
+                // If not, attach the payload to the original error
+                enrichedError.decodedAssertionPayload = decodedPayload;
+            }
+        } catch  {
+        // Ignore errors decoding the payload
+        }
+    }
+    try {
+        // Decode the callstack
+        const callStack = extractCallStack(originalError, {
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
+            // We only support handling debug info for the circuit entry point.
+            // So for now we simply index into the first debug info.
+            debugSymbols: parseDebugSymbols(artifact.debug_symbols)[0],
+            files: artifact.file_map
+        });
+        enrichedError.noirCallStack = callStack?.map((errorLocation)=>{
+            if (typeof errorLocation === 'string') {
+                return `at opcode ${errorLocation}`;
+            } else {
+                return `at ${errorLocation.locationText} (${errorLocation.filePath}:${errorLocation.line}:${errorLocation.column})`;
+            }
+        });
+    } catch  {
+    // Ignore errors resolving the callstack
+    }
+    return enrichedError;
+}

package/dest/private/factory.d.ts

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

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

@@ -0,0 +1 @@
+{"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/{providers/factory.js → factory.js}

@@ -1,15 +1,16 @@
-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';
-export function getSimulationProviderConfigFromEnv() {
+export function getSimulatorConfigFromEnv() {
     const { ACVM_BINARY_PATH, ACVM_WORKING_DIRECTORY } = process.env;
     return {
         acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
         acvmBinaryPath: ACVM_BINARY_PATH ? ACVM_BINARY_PATH : undefined
     };
 }
-export async function createSimulationProvider(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 createSimulationProvider(config, logger = createLogger('si
                 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);
 }