@aztec/simulator 0.81.0 → 0.82.0

package/dest/private/providers/acvm_wasm.d.ts

@@ -1,15 +1,14 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
-import { type ACIRCallback } from '../acvm/acvm.js';
+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, type ACIRExecutionResult } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
 import { type SimulationProvider } from './simulation_provider.js';
 export declare class WASMSimulator implements SimulationProvider {
     protected log: import("@aztec/foundation/log").Logger;
     constructor(log?: import("@aztec/foundation/log").Logger);
     init(): Promise<void>;
-    executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap>;
-    executeUserCircuit(acir: Buffer, initialWitness: ACVMWitness, callback: ACIRCallback): Promise<import("../acvm/acvm.js").ACIRExecutionResult>;
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler): Promise<ACVMWitness>;
+    executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
 }
 //# sourceMappingURL=acvm_wasm.d.ts.map

package/dest/private/providers/acvm_wasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acvm_wasm.d.ts","sourceRoot":"","sources":["../../../src/private/providers/acvm_wasm.ts"],"names":[],"mappings":";;AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,kBAAkB,EAAmB,MAAM,0BAA0B,CAAC;AAEpF,qBAAa,aAAc,YAAW,kBAAkB;IAC1C,SAAS,CAAC,GAAG;gBAAH,GAAG,yCAAiC;IAEpD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAUrB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAiCpG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY;CAI3F"}
+{"version":3,"file":"acvm_wasm.d.ts","sourceRoot":"","sources":["../../../src/private/providers/acvm_wasm.ts"],"names":[],"mappings":"AACA,OAAiB,EAAuB,KAAK,kBAAkB,EAAkB,MAAM,qBAAqB,CAAC;AAE7G,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAQ,MAAM,iBAAiB,CAAC;AACpF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,kBAAkB,EAAmB,MAAM,0BAA0B,CAAC;AAEpF,qBAAa,aAAc,YAAW,kBAAkB;IAC1C,SAAS,CAAC,GAAG;gBAAH,GAAG,yCAAiC;IAEpD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAUrB,sBAAsB,CAC1B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC;IAiCjB,kBAAkB,CACtB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,gCAAgC,EAC1C,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC;CAIhC"}

package/dest/private/providers/acvm_wasm.js

@@ -1,7 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import initACVM, { executeCircuit } from '@aztec/noir-acvm_js';
 import initAbi from '@aztec/noir-noirc_abi';
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
 import { acvm } from '../acvm/acvm.js';
 import { enrichNoirError } from './simulation_provider.js';
 export class WASMSimulator {
@@ -20,43 +19,42 @@ export class WASMSimulator {
             ]);
         }
     }
-    async executeProtocolCircuit(input, compiledCircuit) {
+    async executeProtocolCircuit(input, artifact, callback) {
         this.log.debug('init', {
-            hash: compiledCircuit.hash
+            hash: artifact.hash
         });
         await this.init();
-        // Execute the circuit on those initial witness values
-        //
         // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-        const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+        const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
         //
         // Execute the circuit
         try {
-            const _witnessMap = await executeCircuit(decodedBytecode, input, foreignCallHandler);
+            const result = await executeCircuit(decodedBytecode, input, callback);
             this.log.debug('execution successful', {
-                hash: compiledCircuit.hash
+                hash: artifact.hash
             });
-            return _witnessMap;
+            return result;
         } catch (err) {
-            // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
+            // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
+            // assertion payload.
             if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
-                const parsed = enrichNoirError(compiledCircuit, err);
+                const parsed = enrichNoirError(artifact, err);
                 this.log.debug('execution failed', {
-                    hash: compiledCircuit.hash,
+                    hash: artifact.hash,
                     error: parsed,
                     message: parsed.message
                 });
                 throw parsed;
             }
             this.log.debug('execution failed', {
-                hash: compiledCircuit.hash,
+                hash: artifact.hash,
                 error: err
             });
             throw new Error(`Circuit execution failed: ${err}`);
         }
     }
-    async executeUserCircuit(acir, initialWitness, callback) {
+    async executeUserCircuit(input, artifact, callback) {
         await this.init();
-        return acvm(acir, initialWitness, callback);
+        return acvm(artifact.bytecode, input, callback);
     }
 }

package/dest/private/providers/acvm_wasm_with_blobs.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+import { type ForeignCallHandler } from '@aztec/noir-acvm_js';
 import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
 import { type SimulationProvider } from './simulation_provider.js';
@@ -13,7 +13,7 @@ import { type SimulationProvider } from './simulation_provider.js';
  * It is only used in the context of server-side code executing simulated protocol circuits.
  */
 export declare class WASMSimulatorWithBlobs implements SimulationProvider {
-    executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap>;
-    executeUserCircuit(_acir: Buffer, _initialWitness: ACVMWitness, _callback: ACIRCallback): Promise<ACIRExecutionResult>;
+    executeProtocolCircuit(input: WitnessMap, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler): Promise<WitnessMap>;
+    executeUserCircuit(_input: ACVMWitness, _artifact: FunctionArtifactWithContractName, _callback: ACIRCallback): Promise<ACIRExecutionResult>;
 }
 //# sourceMappingURL=acvm_wasm_with_blobs.d.ts.map

package/dest/private/providers/acvm_wasm_with_blobs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acvm_wasm_with_blobs.d.ts","sourceRoot":"","sources":["../../../src/private/providers/acvm_wasm_with_blobs.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,kBAAkB,EAAmB,MAAM,0BAA0B,CAAC;AAEpF;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IACzD,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAwB1G,kBAAkB,CAChB,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAC5B,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,mBAAmB,CAAC;CAGhC"}
+{"version":3,"file":"acvm_wasm_with_blobs.d.ts","sourceRoot":"","sources":["../../../src/private/providers/acvm_wasm_with_blobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,kBAAkB,EAAkB,MAAM,qBAAqB,CAAC;AACnG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,KAAK,kBAAkB,EAAmB,MAAM,0BAA0B,CAAC;AAEpF;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IACzD,sBAAsB,CAC1B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,CAAC;IAuBtB,kBAAkB,CAChB,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,gCAAgC,EAC3C,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,mBAAmB,CAAC;CAGhC"}

package/dest/private/providers/acvm_wasm_with_blobs.js

@@ -1,5 +1,4 @@
 import { executeCircuit } from '@aztec/noir-acvm_js';
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
 import { enrichNoirError } from './simulation_provider.js';
 /**
  * A simulation provider that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
@@ -8,25 +7,24 @@ import { enrichNoirError } from './simulation_provider.js';
  *
  * It is only used in the context of server-side code executing simulated protocol circuits.
  */ export class WASMSimulatorWithBlobs {
-    async executeProtocolCircuit(input, compiledCircuit) {
-        // Execute the circuit on those initial witness values
-        //
+    async executeProtocolCircuit(input, artifact, callback) {
         // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-        const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+        const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
         //
         // Execute the circuit
         try {
-            const _witnessMap = await executeCircuit(decodedBytecode, input, foreignCallHandler);
+            const _witnessMap = await executeCircuit(decodedBytecode, input, callback);
             return _witnessMap;
         } catch (err) {
-            // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
+            // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
+            // assertion payload.
             if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
-                throw enrichNoirError(compiledCircuit, err);
+                throw enrichNoirError(artifact, err);
             }
             throw new Error(`Circuit execution failed: ${err}`);
         }
     }
-    executeUserCircuit(_acir, _initialWitness, _callback) {
+    executeUserCircuit(_input, _artifact, _callback) {
         throw new Error('Not implemented');
     }
 }

package/dest/private/providers/circuit_recording/circuit_recorder.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { ForeignCallHandler } from '@aztec/noir-acvm_js';
+import type { ACIRCallback } from '../../acvm/acvm.js';
+import type { ACVMWitness } from '../../acvm/acvm_types.js';
+/**
+ * Class responsible for recording circuit inputs necessary to replay the circuit. These inputs are the initial witness
+ * map and the oracle calls made during the circuit execution/witness generation.
+ *
+ * The recording is stored in a JSON file called `circuit_name_circuit_function_name_YYYY-MM-DD_N.json` where N is
+ * a counter to ensure unique filenames. The file is stored in the `recordDir` directory provided as a parameter to
+ * CircuitRecorder.start().
+ *
+ * Example recording file:
+ * ```json
+ * {
+ *   "circuitName": "AMM",
+ *   "functionName": "add_liquidity",
+ *   "bytecodeMd5Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
+ *   "timestamp": 1740691464360,
+ *   "inputs": {
+ *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
+ *     "1": "0x00f4d59c0ff773427bb0fed5b422557ca4dc5655abe53d31fa9408cb3c5a672f",
+ *     "5": "0x000000000000000000000000000000000000000000000000000000000000000f"
+ *   },
+ *   "oracleCalls": [
+ *     {
+ *       "name": "loadCapsule",
+ *       "inputs": [
+ *         [
+ *           "0x102422483bad6abd385948435667e144ac4c272576e325e7563608876cd446fd"
+ *         ],
+ *         [
+ *           "0x000000000000000000000000000000000000000000000000000000000000004d"
+ *         ],
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000001"
+ *         ]
+ *       ],
+ *       "outputs": [
+ *         "0x0000000000000000000000000000000000000000000000000000000000000000",
+ *         [
+ *           "0x0000000000000000000000000000000000000000000000000000000000000000"
+ *         ]
+ *       ]
+ *     },
+ *     {
+ *       "name": "syncNotes",
+ *       "inputs": []
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+export declare class CircuitRecorder {
+    #private;
+    private readonly filePath;
+    private readonly logger;
+    private isFirstCall;
+    private constructor();
+    /**
+     * Initializes a new circuit recording session.
+     * @param recordDir - Directory to store the recording
+     * @param input - Circuit input witness
+     * @param circuitBytecode - Compiled circuit bytecode
+     * @param circuitName - Name of the circuit
+     * @param functionName - Name of the circuit function (defaults to 'main'). This is meaningful only for
+     * contracts as protocol circuits artifacts always contain a single entrypoint function called 'main'.
+     * @returns A new CircuitRecorder instance
+     */
+    static start(recordDir: string, input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName?: string): Promise<CircuitRecorder>;
+    /**
+     * Wraps a callback to record all oracle/foreign calls.
+     * @param callback - The original callback to wrap, either a user circuit callback or protocol circuit callback.
+     * @returns A wrapped callback that records all oracle interactions.
+     */
+    wrapCallback(callback: ACIRCallback | ForeignCallHandler | undefined): ACIRCallback | ForeignCallHandler | undefined;
+    /**
+     * Finalizes the recording file by adding closing brackets. Without calling this method, the recording file is
+     * incomplete and it fails to parse.
+     */
+    finish(): Promise<void>;
+    /**
+     * 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<void>;
+}
+//# sourceMappingURL=circuit_recorder.d.ts.map

package/dest/private/providers/circuit_recording/circuit_recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit_recorder.d.ts","sourceRoot":"","sources":["../../../../src/private/providers/circuit_recording/circuit_recorder.ts"],"names":[],"mappings":";;AACA,OAAO,KAAK,EAAE,kBAAkB,EAAuC,MAAM,qBAAqB,CAAC;AAMnG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,eAAe;;IAIN,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAH7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;IACnE,OAAO,CAAC,WAAW,CAAQ;IAE3B,OAAO;IAEP;;;;;;;;;OASG;WACU,KAAK,CAChB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,YAAY,GAAE,MAAe,GAC5B,OAAO,CAAC,eAAe,CAAC;IAsE3B;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,kBAAkB,GAAG,SAAS,GAAG,YAAY,GAAG,kBAAkB,GAAG,SAAS;IAkFpH;;;OAGG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ7B;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CASrD"}

package/dest/private/providers/circuit_recording/circuit_recorder.js

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

@@ -0,0 +1,18 @@
+import type { ForeignCallHandler } from '@aztec/noir-protocol-circuits-types/types';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
+import type { ACIRCallback, ACIRExecutionResult } from '../../acvm/acvm.js';
+import type { ACVMWitness } from '../../acvm/acvm_types.js';
+import type { SimulationProvider } from '../simulation_provider.js';
+/**
+ * Takes a simulation provider and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
+ * recording works.
+ */
+export declare class SimulationProviderRecorderWrapper implements SimulationProvider {
+    #private;
+    private simulator;
+    constructor(simulator: SimulationProvider);
+    executeProtocolCircuit(input: ACVMWitness, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler | undefined): Promise<ACVMWitness>;
+    executeUserCircuit(input: ACVMWitness, artifact: FunctionArtifactWithContractName, callback: ACIRCallback): Promise<ACIRExecutionResult>;
+}
+//# sourceMappingURL=simulation_provider_recorder_wrapper.d.ts.map

package/dest/private/providers/circuit_recording/simulation_provider_recorder_wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation_provider_recorder_wrapper.d.ts","sourceRoot":"","sources":["../../../../src/private/providers/circuit_recording/simulation_provider_recorder_wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AACpF,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAGpE;;;GAGG;AACH,qBAAa,iCAAkC,YAAW,kBAAkB;;IAC9D,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,kBAAkB;IAEjD,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;CA4ChC"}

package/dest/private/providers/circuit_recording/simulation_provider_recorder_wrapper.js

@@ -0,0 +1,39 @@
+import { CircuitRecorder } from './circuit_recorder.js';
+/**
+ * Takes a simulation provider and wraps it in a circuit recorder. See CircuitRecorder for more details on how circuit
+ * recording works.
+ */ export class SimulationProviderRecorderWrapper {
+    simulator;
+    constructor(simulator){
+        this.simulator = simulator;
+    }
+    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) {
+        const recordDir = process.env.CIRCUIT_RECORD_DIR;
+        if (!recordDir) {
+            // Recording is not enabled so we just execute the circuit
+            return simulateFn(callback);
+        }
+        // Start recording circuit execution
+        const recorder = await CircuitRecorder.start(recordDir, input, bytecode, contractName, functionName);
+        // If callback was provided, we wrap it in a circuit recorder callback wrapper
+        const wrappedCallback = 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 recorder.finishWithError(error);
+            throw error;
+        }
+        // Witness generation is complete so we finish the circuit recorder
+        await recorder.finish();
+        return result;
+    }
+}

package/dest/private/providers/simulation_provider.d.ts

@@ -1,16 +1,30 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { ExecutionError } from '@aztec/noir-acvm_js';
-import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+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';
 /**
  * Low level simulation interface
  */
 export interface SimulationProvider {
-    executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap>;
-    executeUserCircuit(acir: Buffer, initialWitness: ACVMWitness, callback: ACIRCallback): Promise<ACIRExecutionResult>;
+    /**
+     * 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<ACVMWitness>;
+    /**
+     * 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;

package/dest/private/providers/simulation_provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simulation_provider.d.ts","sourceRoot":"","sources":["../../../src/private/providers/simulation_provider.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAoB,MAAM,iBAAiB,CAAC;AAChG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACrG,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACrH;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,CA4C1G"}
+{"version":3,"file":"simulation_provider.d.ts","sourceRoot":"","sources":["../../../src/private/providers/simulation_provider.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,iBAAiB,CAAC;AAChG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;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,CA4C1G"}

package/dest/private/simulator.d.ts

@@ -1,5 +1,6 @@
-import type { FunctionCall } from '@aztec/stdlib/abi';
+import type { AbiDecoded, FunctionCall } from '@aztec/stdlib/abi';
 import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PrivateExecutionResult, TxExecutionRequest } from '@aztec/stdlib/tx';
 import type { ExecutionDataProvider } from './execution_data_provider.js';
@@ -29,6 +30,6 @@ export declare class AcirSimulator {
      * @param contractAddress - The address of the contract.
      * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
      */
-    runUnconstrained(request: FunctionCall, contractAddress: AztecAddress, selector: FunctionSelector, scopes?: AztecAddress[]): Promise<import("@aztec/stdlib/abi").AbiDecoded>;
+    runUnconstrained(request: FunctionCall, contractAddress: AztecAddress, selector: FunctionSelector, authwits: AuthWitness[], scopes?: AztecAddress[]): Promise<AbiDecoded>;
 }
 //# sourceMappingURL=simulator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"simulator.d.ts","sourceRoot":"","sources":["../../src/private/simulator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAgB,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAe,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAK1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAI7E;;GAEG;AACH,qBAAa,aAAa;IAGZ,OAAO,CAAC,qBAAqB;IAAyB,OAAO,CAAC,kBAAkB;IAF5F,OAAO,CAAC,GAAG,CAAS;gBAEA,qBAAqB,EAAE,qBAAqB,EAAU,kBAAkB,EAAE,kBAAkB;IAIhH;;;;;;;;OAQG;IACU,GAAG,CACd,OAAO,EAAE,kBAAkB,EAC3B,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,eAA6C,EACtD,MAAM,CAAC,EAAE,YAAY,EAAE,GACtB,OAAO,CAAC,sBAAsB,CAAC;IA8DlC;;;;;;OAMG;IACU,gBAAgB,CAC3B,OAAO,EAAE,YAAY,EACrB,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,CAAC,EAAE,YAAY,EAAE;CA+B1B"}
+{"version":3,"file":"simulator.d.ts","sourceRoot":"","sources":["../../src/private/simulator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAgB,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAe,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAK1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAI7E;;GAEG;AACH,qBAAa,aAAa;IAGZ,OAAO,CAAC,qBAAqB;IAAyB,OAAO,CAAC,kBAAkB;IAF5F,OAAO,CAAC,GAAG,CAAS;gBAEA,qBAAqB,EAAE,qBAAqB,EAAU,kBAAkB,EAAE,kBAAkB;IAIhH;;;;;;;;OAQG;IACU,GAAG,CACd,OAAO,EAAE,kBAAkB,EAC3B,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,SAAS,eAA6C,EACtD,MAAM,CAAC,EAAE,YAAY,EAAE,GACtB,OAAO,CAAC,sBAAsB,CAAC;IA8DlC;;;;;;OAMG;IACU,gBAAgB,CAC3B,OAAO,EAAE,YAAY,EACrB,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,WAAW,EAAE,EACvB,MAAM,CAAC,EAAE,YAAY,EAAE,GACtB,OAAO,CAAC,UAAU,CAAC;CA8BvB"}