@aztec/simulator 0.87.4 → 0.87.5

package/src/private/providers/circuit_recording/circuit_recorder.ts

@@ -1,59 +1,28 @@
-import { sha512 } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
 import type { ForeignCallHandler, ForeignCallInput, ForeignCallOutput } from '@aztec/noir-acvm_js';
 
+import { createHash } from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+
 import type { ACIRCallback } from '../../acvm/acvm.js';
 import type { ACVMWitness } from '../../acvm/acvm_types.js';
 import { Oracle } from '../../acvm/oracle/oracle.js';
 
-export type OracleCall = {
-  name: string;
-  inputs: unknown[];
-  outputs: unknown;
-  time: number;
-  // Due to the recursive nature of the simulator, we might have
-  // oracle calls performed after a foreign call (which is itself an oracle call)
-  // We keep track of the stack depth in this variable to ensure the recorded oracle
-  // calls are correctly associated with the right circuit.
-  // This is only use as a debugging tool
-  stackDepth: number;
-};
-
-export 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>) {
-    this.circuitName = circuitName;
-    this.functionName = functionName;
-    this.bytecodeSHA512Hash = bytecodeSHA512Hash;
-    this.timestamp = Date.now();
-    this.inputs = inputs;
-    this.oracleCalls = [];
-  }
-
-  setParent(recording?: CircuitRecording): void {
-    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:
+ * 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",
- *   "bytecodeSHA512Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
+ *   "bytecodeMd5Hash": "b46c640ed38f20eac5f61a5e41d8dd1e",
  *   "timestamp": 1740691464360,
  *   "inputs": {
  *     "0": "0x1e89de1f0ad5204263733b7ddf65bec45b8f44714a4da85a46474dad677679ef",
@@ -82,7 +51,7 @@ export class CircuitRecording {
  *       ]
  *     },
  *     {
- *       "name": "fetchTaggedLogs",
+ *       "name": "syncPrivateState",
  *       "inputs": []
  *     }
  *   ]
@@ -90,14 +59,10 @@ export class CircuitRecording {
  * ```
  */
 export class CircuitRecorder {
-  protected readonly logger = createLogger('simulator:acvm:recording');
+  private readonly logger = createLogger('simulator:acvm:recording');
+  private isFirstCall = true;
 
-  protected recording?: CircuitRecording;
-
-  private stackDepth: number = 0;
-  private newCircuit: boolean = true;
-
-  protected constructor() {}
+  private constructor(private readonly filePath: string) {}
 
   /**
    * Initializes a new circuit recording session.
@@ -107,20 +72,82 @@ export 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
    */
-  start(input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName: string): Promise<void> {
-    const parentRef = this.recording;
-    if (this.newCircuit) {
-      this.recording = new CircuitRecording(
-        circuitName,
-        functionName,
-        sha512(circuitBytecode).toString('hex'),
-        Object.fromEntries(input),
-      );
+  static async start(
+    recordDir: string,
+    input: ACVMWitness,
+    circuitBytecode: Buffer,
+    circuitName: string,
+    functionName: string = 'main',
+  ): Promise<CircuitRecorder> {
+    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 as NodeJS.ErrnoException).code === 'ENOENT') {
+        // The directory does not exist so we create it
+        await fs.mkdir(recordDir, { recursive: true });
+      } else {
+        throw err;
+      }
     }
-    this.recording!.setParent(parentRef);
 
-    return Promise.resolve();
+    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: string,
+    circuitName: string,
+    functionName: string,
+    recordingContent: string,
+  ): Promise<string> {
+    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', // wx flag fails if file exists
+        });
+        return filePath;
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
+          counter++;
+          continue;
+        }
+        throw err;
+      }
+    }
   }
 
   /**
@@ -160,38 +187,15 @@ export class CircuitRecorder {
         throw new Error(`Oracle method ${name} not found when setting up recording callback`);
       }
 
-      const isExternalCall = (name as keyof ACIRCallback) === 'callPrivateFunction';
-
       recordingCallback[name as keyof ACIRCallback] = (...args: ForeignCallInput[]): ReturnType<typeof fn> => {
-        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);
+            await this.#recordCall(name, args, r);
             return r;
           }) as ReturnType<typeof fn>;
         }
-        // Once we leave the nested circuit, we decrease the stack depth and set newCircuit to false
-        // since we are going back to the "parent" circuit which can never be new
-        if (isExternalCall) {
-          this.stackDepth--;
-          this.newCircuit = false;
-          this.recording = this.recording!.parent;
-        }
-        void this.recordCall(name, args, result, timer.ms(), this.stackDepth);
+        void this.#recordCall(name, args, result);
         return result;
       };
     }
@@ -206,9 +210,8 @@ export class CircuitRecorder {
    */
   #wrapProtocolCircuitCallback(callback: ForeignCallHandler): ForeignCallHandler {
     return async (name: string, inputs: ForeignCallInput[]): Promise<ForeignCallOutput[]> => {
-      const timer = new Timer();
       const result = await callback(name, inputs);
-      await this.recordCall(name, inputs, result, timer.ms(), 0);
+      await this.#recordCall(name, inputs, result);
       return result;
     };
   }
@@ -219,43 +222,62 @@ export class CircuitRecorder {
    * @param inputs - Input arguments
    * @param outputs - Output results
    */
-  recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number): Promise<OracleCall> {
-    const entry = {
-      name,
-      inputs,
-      outputs,
-      time,
-      stackDepth,
-    };
-    this.recording!.oracleCalls.push(entry);
-    return Promise.resolve(entry);
+  async #recordCall(name: string, inputs: unknown[], outputs: unknown) {
+    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 by resetting the state and returning the recording object.
+   * 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> {
-    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;
+  async finish(): Promise<void> {
+    try {
+      await fs.appendFile(this.filePath, '  ]\n}\n');
+    } catch (err) {
+      this.logger.error('Failed to finalize recording file', { error: err });
     }
-    return Promise.resolve(result!);
   }
 
   /**
-   * Finalizes the recording by resetting the state and returning the recording object with an attached error.
+   * 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> {
-    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;
+  async finishWithError(error: unknown): Promise<void> {
+    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 });
     }
-    result!.error = JSON.stringify(error);
-    return Promise.resolve(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: string, circuitName: string, functionName: string, counter: number): string {
+  const date = new Date();
+  const formattedDate = date.toISOString().split('T')[0];
+  const filename = `${circuitName}_${functionName}_${formattedDate}_${counter}.json`;
+  return path.join(recordDir, filename);
+}

package/src/private/providers/circuit_recording/simulation_provider_recorder_wrapper.ts

@@ -2,21 +2,18 @@ import type { ForeignCallHandler } from '@aztec/noir-protocol-circuits-types/typ
 import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
 import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
-import type { ACIRCallback, ACIRCallbackStats, ACIRExecutionResult } from '../../acvm/acvm.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 { CircuitRecorder } from './circuit_recorder.js';
+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 implements SimulationProvider {
-  constructor(
-    private simulator: SimulationProvider,
-    private recorder: CircuitRecorder,
-  ) {}
+  constructor(private simulator: SimulationProvider) {}
 
   executeProtocolCircuit(
     input: ACVMWitness,
@@ -50,7 +47,7 @@ export class SimulationProviderRecorderWrapper implements SimulationProvider {
     );
   }
 
-  async #simulate<C extends ACIRCallback | ForeignCallHandler | undefined, T extends ACIRExecutionResult | ACVMSuccess>(
+  async #simulate<C extends ACIRCallback | ForeignCallHandler | undefined, T>(
     simulateFn: (wrappedCallback: C) => Promise<T>,
     input: ACVMWitness,
     bytecode: Buffer,
@@ -58,33 +55,28 @@ export class SimulationProviderRecorderWrapper implements SimulationProvider {
     functionName: string,
     callback: C,
   ): Promise<T> {
+    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
-    await this.recorder.start(input, bytecode, contractName, functionName);
+    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 = this.recorder.wrapCallback(callback);
+    const wrappedCallback = recorder.wrapCallback(callback);
     let result: T;
     try {
       result = await simulateFn(wrappedCallback as C);
     } catch (error) {
       // If an error occurs, we finalize the recording file with the error
-      await this.recorder.finishWithError(error);
+      await recorder.finishWithError(error);
       throw error;
     }
 
     // Witness generation is complete so we finish the circuit recorder
-    const recording = await this.recorder.finish();
-
-    (result as ACIRExecutionResult).oracles = recording.oracleCalls?.reduce(
-      (acc, { time, name }) => {
-        if (!acc[name]) {
-          acc[name] = { times: [] };
-        }
-        acc[name].times.push(time);
-        return acc;
-      },
-      {} as Record<string, ACIRCallbackStats>,
-    );
+    await recorder.finish();
 
     return result;
   }

package/src/private/utility_execution_oracle.ts

@@ -274,7 +274,7 @@ export class UtilityExecutionOracle extends TypedOracle {
     return await this.executionDataProvider.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
   }
 
-  public override async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr) {
+  public override async syncPrivateState(pendingTaggedLogArrayBaseSlot: Fr) {
     await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);

package/src/public/avm/fixtures/base_avm_simulation_tester.ts

@@ -100,9 +100,4 @@ export abstract class BaseAvmSimulationTester {
     );
     await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()]);
   }
-
-  async insertNullifier(contractThatEmitted: AztecAddress, nullifier: Fr) {
-    const siloedNullifier = await siloNullifier(contractThatEmitted, nullifier);
-    await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()]);
-  }
 }

package/src/public/public_tx_simulator/apps_tests/amm_test.ts

@@ -1,5 +1,3 @@
-import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import { AMMContractArtifact } from '@aztec/noir-contracts.js/AMM';
@@ -139,24 +137,6 @@ async function addLiquidity(
   const liquidityPartialNote = {
     commitment: new Fr(99),
   };
-  const refundToken0PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
-    refundToken0PartialNote,
-    amm.address,
-  );
-  const refundToken1PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
-    refundToken1PartialNote,
-    amm.address,
-  );
-  const liquidityPartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
-    liquidityPartialNote,
-    amm.address,
-  );
-
-  // We need to inject the validity commitments into the nullifier tree as that would be performed by the private token
-  // functions that are not invoked in this test.
-  await tester.insertNullifier(token0.address, refundToken0PartialNoteValidityCommitment);
-  await tester.insertNullifier(token1.address, refundToken1PartialNoteValidityCommitment);
-  await tester.insertNullifier(liquidityToken.address, liquidityPartialNoteValidityCommitment);
 
   return await tester.simulateTxWithLabel(
     /*txLabel=*/ 'AMM/add_liquidity',
@@ -170,6 +150,13 @@ async function addLiquidity(
         args: [/*to=*/ amm.address, /*amount=*/ amount0Max],
         address: token0.address,
       },
+      // token0.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [refundToken0PartialNote],
+        address: token0.address,
+      },
       // token1.transfer_to_public enqueues a call to _increase_public_balance
       {
         sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
@@ -177,6 +164,20 @@ async function addLiquidity(
         args: [/*to=*/ amm.address, /*amount=*/ amount1Max],
         address: token1.address,
       },
+      // token1.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [refundToken1PartialNote],
+        address: token1.address,
+      },
+      // liquidityToken.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: liquidityToken.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [liquidityPartialNote],
+        address: liquidityToken.address,
+      },
       // amm.add_liquidity enqueues a call to _add_liquidity
       {
         sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
@@ -213,16 +214,8 @@ async function swapExactTokensForTokens(
   _nonce?: bigint,
 ) {
   const tokenOutPartialNote = {
-    commitment: new Fr(166),
+    commitment: new Fr(66),
   };
-  const tokenOutPartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
-    tokenOutPartialNote,
-    amm.address,
-  );
-
-  // We need to inject the validity commitment into the nullifier tree as that would be performed by the private token
-  // function that is not invoked in this test.
-  await tester.insertNullifier(tokenOut.address, tokenOutPartialNoteValidityCommitment);
 
   return await tester.simulateTxWithLabel(
     /*txLabel=*/ 'AMM/swap_exact_tokens_for_tokens',
@@ -236,6 +229,14 @@ async function swapExactTokensForTokens(
         args: [/*to=*/ amm.address, /*amount=*/ amountIn],
         address: tokenIn.address,
       },
+      // tokenOut.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: tokenOut.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [tokenOutPartialNote],
+        address: tokenOut.address,
+      },
+
       {
         sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
         fnName: '_swap_exact_tokens_for_tokens',
@@ -264,19 +265,6 @@ async function removeLiquidity(
   const token1PartialNote = {
     commitment: new Fr(222),
   };
-  const token0PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
-    token0PartialNote,
-    amm.address,
-  );
-  const token1PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
-    token1PartialNote,
-    amm.address,
-  );
-
-  // We need to inject the validity commitments into the nullifier tree as that would be performed by the private token
-  // functions that are not invoked in this test.
-  await tester.insertNullifier(token0.address, token0PartialNoteValidityCommitment);
-  await tester.insertNullifier(token1.address, token1PartialNoteValidityCommitment);
 
   return await tester.simulateTxWithLabel(
     /*txLabel=*/ 'AMM/remove_liquidity',
@@ -290,6 +278,20 @@ async function removeLiquidity(
         args: [/*to=*/ amm.address, /*amount=*/ liquidity],
         address: liquidityToken.address,
       },
+      // token0.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [token0PartialNote],
+        address: token0.address,
+      },
+      // token1.prepare_private_balance_increase enqueues a call to _store_balances_set_partial_note
+      {
+        sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_store_balances_set_partial_note',
+        args: [token1PartialNote],
+        address: token1.address,
+      },
       // amm.remove_liquidity enqueues a call to _remove_liquidity
       {
         sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
@@ -312,10 +314,3 @@ async function removeLiquidity(
     ],
   );
 }
-
-async function computePartialNoteValidityCommitment(partialNote: { commitment: Fr }, completer: AztecAddress) {
-  return await poseidon2HashWithSeparator(
-    [partialNote.commitment, completer],
-    GeneratorIndex.PARTIAL_NOTE_VALIDITY_COMMITMENT,
-  );
-}

package/src/server.ts

@@ -1,7 +1,5 @@
 export * from './public/index.js';
 export { WASMSimulatorWithBlobs } from './private/providers/acvm_wasm_with_blobs.js';
 export { NativeACVMSimulator } from './private/providers/acvm_native.js';
-export { SimulationProviderRecorderWrapper } from './private/providers/circuit_recording/simulation_provider_recorder_wrapper.js';
-export { MemoryCircuitRecorder } from './private/providers/circuit_recording/memory_circuit_recorder.js';
 export { type SimulationProvider } from './private/providers/simulation_provider.js';
 export * from './common/index.js';

package/src/testing.ts

@@ -1 +1 @@
-export { FileCircuitRecorder } from './private/providers/circuit_recording/file_circuit_recorder.js';
+export { SimulationProviderRecorderWrapper } from './private/providers/circuit_recording/simulation_provider_recorder_wrapper.js';

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

@@ -1,31 +0,0 @@
-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/providers/circuit_recording/file_circuit_recorder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file_circuit_recorder.d.ts","sourceRoot":"","sources":["../../../../src/private/providers/circuit_recording/file_circuit_recorder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,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"}