@aztec/simulator 0.87.5 → 0.87.7

package/dest/client.d.ts

@@ -1,5 +1,7 @@
-export * from './private/index.js';
-export { WASMSimulator } from './private/providers/acvm_wasm.js';
-export { type SimulationProvider, type DecodedError } from './private/providers/simulation_provider.js';
+export * from './private/acvm/index.js';
+export { WASMSimulator } from './private/acvm_wasm.js';
+export { SimulatorRecorderWrapper } from './private/circuit_recording/simulator_recorder_wrapper.js';
+export { MemoryCircuitRecorder } from './private/circuit_recording/memory_circuit_recorder.js';
+export { type CircuitSimulator, type DecodedError } from './private/circuit_simulator.js';
 export * from './common/index.js';
 //# sourceMappingURL=client.d.ts.map

package/dest/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,4CAA4C,CAAC;AACxG,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,2DAA2D,CAAC;AACrG,OAAO,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAC/F,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC1F,cAAc,mBAAmB,CAAC"}

package/dest/client.js

@@ -1,3 +1,5 @@
-export * from './private/index.js';
-export { WASMSimulator } from './private/providers/acvm_wasm.js';
+export * from './private/acvm/index.js';
+export { WASMSimulator } from './private/acvm_wasm.js';
+export { SimulatorRecorderWrapper } from './private/circuit_recording/simulator_recorder_wrapper.js';
+export { MemoryCircuitRecorder } from './private/circuit_recording/memory_circuit_recorder.js';
 export * from './common/index.js';

package/dest/private/acvm/acvm.d.ts

@@ -2,11 +2,13 @@ import { type ExecutionError, type ForeignCallInput, type ForeignCallOutput } fr
 import type { FunctionDebugMetadata } from '@aztec/stdlib/abi';
 import type { NoirCallStack } from '@aztec/stdlib/errors';
 import type { ACVMWitness } from './acvm_types.js';
-import type { ORACLE_NAMES } from './oracle/index.js';
 /**
  * The callback interface for the ACIR.
  */
-export type ACIRCallback = Record<ORACLE_NAMES, (...args: ForeignCallInput[]) => Promise<ForeignCallOutput[]>>;
+export type ACIRCallback = Record<string, (...args: ForeignCallInput[]) => Promise<ForeignCallOutput[]>>;
+export type ACIRCallbackStats = {
+    times: number[];
+};
 /**
  * The result of executing an ACIR.
  */
@@ -18,6 +20,7 @@ export interface ACIRExecutionResult {
      */
     partialWitness: ACVMWitness;
     returnWitness: ACVMWitness;
+    oracles?: Record<string, ACIRCallbackStats>;
 }
 /**
  * The function call that executes an ACIR.

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

@@ -1 +1 @@
-{"version":3,"file":"acvm.d.ts","sourceRoot":"","sources":["../../../src/private/acvm/acvm.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,gBAAgB,EAAE,KAAK,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;AAE/G;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,cAAc,EAAE,WAAW,CAAC;IAC5B,aAAa,EAAE,WAAW,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAsB,IAAI,CACxB,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,WAAW,EAC3B,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAwC9B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,GAAG,cAAc,EAC7B,KAAK,CAAC,EAAE,qBAAqB,GAC5B,aAAa,GAAG,SAAS,CAc3B"}
+{"version":3,"file":"acvm.d.ts","sourceRoot":"","sources":["../../../src/private/acvm/acvm.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,gBAAgB,EAAE,KAAK,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;AAEzG,MAAM,MAAM,iBAAiB,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,cAAc,EAAE,WAAW,CAAC;IAC5B,aAAa,EAAE,WAAW,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,wBAAsB,IAAI,CACxB,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,WAAW,EAC3B,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAwC9B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,GAAG,cAAc,EAC7B,KAAK,CAAC,EAAE,qBAAqB,GAC5B,aAAa,GAAG,SAAS,CAc3B"}

package/dest/private/acvm/index.d.ts

@@ -1,6 +1,5 @@
 export { extractCallStack, type ACIRCallback, type ACIRExecutionResult } from './acvm.js';
 export * from './acvm_types.js';
 export * from './deserialize.js';
-export * from './oracle/index.js';
 export * from './serialize.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/private/acvm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/private/acvm/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC1F,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/private/acvm/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC1F,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/dest/private/acvm/index.js

@@ -1,5 +1,4 @@
 export { extractCallStack } from './acvm.js';
 export * from './acvm_types.js';
 export * from './deserialize.js';
-export * from './oracle/index.js';
 export * from './serialize.js';

package/dest/private/{providers/acvm_native.d.ts → acvm_native.d.ts}

@@ -2,9 +2,9 @@ import type { WitnessMap } from '@aztec/noir-acvm_js';
 import type { ForeignCallHandler } from '@aztec/noir-protocol-circuits-types/types';
 import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
 import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
-import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
-import type { ACVMWitness } from '../acvm/acvm_types.js';
-import type { SimulationProvider } from './simulation_provider.js';
+import type { ACIRCallback, ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
+import type { CircuitSimulator } from './circuit_simulator.js';
 export declare enum ACVM_RESULT {
     SUCCESS = 0,
     FAILURE = 1
@@ -29,7 +29,7 @@ export type ACVMResult = ACVMSuccess | ACVMFailure;
  * @returns The completed partial witness outputted from the circuit
  */
 export declare function executeNativeCircuit(inputWitness: WitnessMap, bytecode: Buffer, workingDirectory: string, pathToAcvm: string, outputFilename?: string): Promise<ACVMResult>;
-export declare class NativeACVMSimulator implements SimulationProvider {
+export declare class NativeACVMSimulator implements CircuitSimulator {
     private workingDirectory;
     private pathToAcvm;
     private witnessFilename?;

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_native.d.ts","sourceRoot":"","sources":["../../src/private/acvm_native.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,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;AAKtE,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,oBAAY,WAAW;IACrB,OAAO,IAAA;IACP,OAAO,IAAA;CACR;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAmBnD;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,UAAU,EACxB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,UAAU,CAAC,CAsErB;AAED,qBAAa,mBAAoB,YAAW,gBAAgB;IAExD,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,eAAe,CAAC;gBAFhB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,eAAe,CAAC,EAAE,MAAM,YAAA;IAG5B,sBAAsB,CAC1B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,OAAO,CAAC,WAAW,CAAC;IA6BvB,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.d.ts → acvm_wasm.d.ts}

@@ -1,11 +1,11 @@
 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 ACIRCallback, type ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
 import type { ACVMSuccess } from './acvm_native.js';
-import { type SimulationProvider } from './simulation_provider.js';
-export declare class WASMSimulator implements SimulationProvider {
+import { type CircuitSimulator } from './circuit_simulator.js';
+export declare class WASMSimulator implements CircuitSimulator {
     protected log: import("@aztec/foundation/log").Logger;
     constructor(log?: import("@aztec/foundation/log").Logger);
     init(): Promise<void>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_wasm.d.ts","sourceRoot":"","sources":["../../src/private/acvm_wasm.ts"],"names":[],"mappings":"AAEA,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,gBAAgB,CAAC;AACnF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAmB,MAAM,wBAAwB,CAAC;AAEhF,qBAAa,aAAc,YAAW,gBAAgB;IACxC,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;IAkCjB,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 → acvm_wasm.js}

@@ -2,8 +2,8 @@ import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import initACVM, { executeCircuit } from '@aztec/noir-acvm_js';
 import initAbi from '@aztec/noir-noirc_abi';
-import { acvm } from '../acvm/acvm.js';
-import { enrichNoirError } from './simulation_provider.js';
+import { acvm } from './acvm/acvm.js';
+import { enrichNoirError } from './circuit_simulator.js';
 export class WASMSimulator {
     log;
     constructor(log = createLogger('wasm-simulator')){

package/dest/private/{providers/acvm_wasm_with_blobs.d.ts → acvm_wasm_with_blobs.d.ts}

@@ -2,18 +2,18 @@ import { type ForeignCallHandler } from '@aztec/noir-acvm_js';
 import type { WitnessMap } from '@aztec/noir-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 { ACIRCallback, ACIRExecutionResult } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
 import type { ACVMSuccess } from './acvm_native.js';
-import { type SimulationProvider } from './simulation_provider.js';
+import { type CircuitSimulator } from './circuit_simulator.js';
 /**
- * A simulation provider that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
+ * A circuit simulator that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
  * This class is temporary while brillig cannot handle the blob math, and it is kept separate
  * because the zkg commitment library used in the blob code is not browser compatible.
  *
  * It is only used in the context of server-side code executing simulated protocol circuits.
  */
-export declare class WASMSimulatorWithBlobs implements SimulationProvider {
+export declare class WASMSimulatorWithBlobs implements CircuitSimulator {
     executeProtocolCircuit(input: WitnessMap, artifact: NoirCompiledCircuitWithName, callback: ForeignCallHandler): Promise<ACVMSuccess>;
     executeUserCircuit(_input: ACVMWitness, _artifact: FunctionArtifactWithContractName, _callback: ACIRCallback): Promise<ACIRExecutionResult>;
 }

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

@@ -0,0 +1 @@
+{"version":3,"file":"acvm_wasm_with_blobs.d.ts","sourceRoot":"","sources":["../../src/private/acvm_wasm_with_blobs.ts"],"names":[],"mappings":"AACA,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,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAmB,MAAM,wBAAwB,CAAC;AAEhF;;;;;;GAMG;AACH,qBAAa,sBAAuB,YAAW,gBAAgB;IACvD,sBAAsB,CAC1B,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,2BAA2B,EACrC,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC;IAuBvB,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 → acvm_wasm_with_blobs.js}

@@ -1,8 +1,8 @@
 import { Timer } from '@aztec/foundation/timer';
 import { executeCircuit } from '@aztec/noir-acvm_js';
-import { enrichNoirError } from './simulation_provider.js';
+import { enrichNoirError } from './circuit_simulator.js';
 /**
- * A simulation provider that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
+ * A circuit simulator that uses the WASM simulator with the ability to handle blobs via the foreign call handler.
  * This class is temporary while brillig cannot handle the blob math, and it is kept separate
  * because the zkg commitment library used in the blob code is not browser compatible.
  *

package/dest/private/{providers/circuit_recording → circuit_recording}/circuit_recorder.d.ts

@@ -1,20 +1,35 @@
 import type { ForeignCallHandler } from '@aztec/noir-acvm_js';
-import type { ACIRCallback } from '../../acvm/acvm.js';
-import type { ACVMWitness } from '../../acvm/acvm_types.js';
+import type { ACIRCallback } from '../acvm/acvm.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
+export type OracleCall = {
+    name: string;
+    inputs: unknown[];
+    outputs: unknown;
+    time: number;
+    stackDepth: number;
+};
+export declare class CircuitRecording {
+    circuitName: string;
+    functionName: string;
+    bytecodeSHA512Hash: string;
+    timestamp: number;
+    inputs: Record<string, string>;
+    oracleCalls: OracleCall[];
+    error?: string;
+    parent?: CircuitRecording;
+    constructor(circuitName: string, functionName: string, bytecodeSHA512Hash: string, inputs: Record<string, string>);
+    setParent(recording?: CircuitRecording): void;
+}
 /**
  * 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:
+ * Example recording object:
  * ```json
  * {
  *   "circuitName": "AMM",
  *   "functionName": "add_liquidity",
- *   "bytecodeMd5Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
+ *   "bytecodeSHA512Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
  *   "timestamp": 1740691464360,
  *   "inputs": {
  *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
@@ -43,7 +58,7 @@ import type { ACVMWitness } from '../../acvm/acvm_types.js';
  *       ]
  *     },
  *     {
- *       "name": "syncPrivateState",
+ *       "name": "fetchTaggedLogs",
  *       "inputs": []
  *     }
  *   ]
@@ -52,10 +67,11 @@ import type { ACVMWitness } from '../../acvm/acvm_types.js';
  */
 export declare class CircuitRecorder {
     #private;
-    private readonly filePath;
-    private readonly logger;
-    private isFirstCall;
-    private constructor();
+    protected readonly logger: import("@aztec/foundation/log").Logger;
+    protected recording?: CircuitRecording;
+    private stackDepth;
+    private newCircuit;
+    protected constructor();
     /**
      * Initializes a new circuit recording session.
      * @param recordDir - Directory to store the recording
@@ -64,9 +80,8 @@ export declare class CircuitRecorder {
      * @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>;
+    start(input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName: string): Promise<void>;
     /**
      * 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.
@@ -74,15 +89,20 @@ export declare class CircuitRecorder {
      */
     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.
+     * 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<OracleCall>;
+    /**
+     * Finalizes the recording by resetting the state and returning the recording object.
      */
-    finish(): Promise<void>;
+    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.
+     * Finalizes the recording by resetting the state and returning the recording object with an attached error.
      * @param error - The error that occurred during circuit execution
      */
-    finishWithError(error: unknown): Promise<void>;
+    finishWithError(error: unknown): Promise<CircuitRecording>;
 }
 //# sourceMappingURL=circuit_recorder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"circuit_recorder.d.ts","sourceRoot":"","sources":["../../../src/private/circuit_recording/circuit_recorder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAuC,MAAM,qBAAqB,CAAC;AAEnG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IAMb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,qBAAa,gBAAgB;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,gBAAgB,CAAC;gBAEd,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IASjH,SAAS,CAAC,SAAS,CAAC,EAAE,gBAAgB,GAAG,IAAI;CAG9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,eAAe;;IAC1B,SAAS,CAAC,QAAQ,CAAC,MAAM,yCAA4C;IAErE,SAAS,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAEvC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,UAAU,CAAiB;IAEnC,SAAS;IAET;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAe5G;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,kBAAkB,GAAG,SAAS,GAAG,YAAY,GAAG,kBAAkB,GAAG,SAAS;IAqFpH;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAYpH;;OAEG;IACH,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAUnC;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAU3D"}

package/dest/private/circuit_recording/circuit_recorder.js

@@ -0,0 +1,209 @@
+import { sha512 } from '@aztec/foundation/crypto';
+import { createLogger } 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 = createLogger('simulator:acvm:recording');
+    recording;
+    stackDepth = 0;
+    newCircuit = true;
+    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'.
+   */ 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();
+    }
+    /**
+   * 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 === 'callPrivateFunction';
+            recordingCallback[name] = (...args)=>{
+                const timer = new Timer();
+                // If we're entering another circuit via `callPrivateFunction`, 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);
+                        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);
+                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;
+        }
+        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
+   */ 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);
+    }
+}

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

@@ -0,0 +1,31 @@
+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);
+    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=file_circuit_recorder.d.ts.map

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":"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"}