@aztec/simulator 0.41.0 → 0.43.0

package/src/client/execution_result.ts

@@ -1,6 +1,8 @@
 import {
   EncryptedFunctionL2Logs,
   type EncryptedL2Log,
+  type EncryptedL2NoteLog,
+  EncryptedNoteFunctionL2Logs,
   type Note,
   UnencryptedFunctionL2Logs,
   type UnencryptedL2Log,
@@ -22,7 +24,7 @@ export interface NoteAndSlot {
   noteTypeId: Fr;
 }
 
-export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2Log> implements IsEmpty {
+export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2NoteLog | EncryptedL2Log> implements IsEmpty {
   constructor(public log: TLog, public counter: number) {}
 
   isEmpty(): boolean {
@@ -30,6 +32,11 @@ export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2Log> implemen
   }
 }
 
+export class CountedNoteLog extends CountedLog<EncryptedL2NoteLog> {
+  constructor(log: EncryptedL2NoteLog, counter: number, public noteHashCounter: number) {
+    super(log, counter);
+  }
+}
 /**
  * The result of executing a private function.
  */
@@ -62,7 +69,7 @@ export interface ExecutionResult {
    * Encrypted note logs emitted during execution of this function call.
    * Note: These are preimages to `noteEncryptedLogsHashes`.
    */
-  noteEncryptedLogs: CountedLog<EncryptedL2Log>[];
+  noteEncryptedLogs: CountedNoteLog[];
   /**
    * Encrypted logs emitted during execution of this function call.
    * Note: These are preimages to `encryptedLogsHashes`.
@@ -92,8 +99,14 @@ export function collectNullifiedNoteHashCounters(execResult: ExecutionResult, ac
  * @param execResult - The topmost execution result.
  * @returns All encrypted logs.
  */
-function collectNoteEncryptedLogs(execResult: ExecutionResult): CountedLog<EncryptedL2Log>[] {
-  return [execResult.noteEncryptedLogs, ...execResult.nestedExecutions.flatMap(collectNoteEncryptedLogs)].flat();
+function collectNoteEncryptedLogs(
+  execResult: ExecutionResult,
+  nullifiedNoteHashCounters: Map<number, number>,
+): CountedLog<EncryptedL2NoteLog>[] {
+  return [
+    execResult.noteEncryptedLogs.filter(noteLog => !nullifiedNoteHashCounters.has(noteLog.noteHashCounter)),
+    ...execResult.nestedExecutions.flatMap(res => collectNoteEncryptedLogs(res, nullifiedNoteHashCounters)),
+  ].flat();
 }
 
 /**
@@ -101,10 +114,11 @@ function collectNoteEncryptedLogs(execResult: ExecutionResult): CountedLog<Encry
  * @param execResult - The topmost execution result.
  * @returns All encrypted logs.
  */
-export function collectSortedNoteEncryptedLogs(execResult: ExecutionResult): EncryptedFunctionL2Logs {
-  const allLogs = collectNoteEncryptedLogs(execResult);
+export function collectSortedNoteEncryptedLogs(execResult: ExecutionResult): EncryptedNoteFunctionL2Logs {
+  const nullifiedNoteHashCounters = collectNullifiedNoteHashCounters(execResult);
+  const allLogs = collectNoteEncryptedLogs(execResult, nullifiedNoteHashCounters);
   const sortedLogs = sortByCounter(allLogs);
-  return new EncryptedFunctionL2Logs(sortedLogs.map(l => l.log));
+  return new EncryptedNoteFunctionL2Logs(sortedLogs.map(l => l.log));
 }
 /**
  * Collect all encrypted logs across all nested executions.

package/src/client/private_execution.ts

@@ -1,14 +1,15 @@
-import { type FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
-import { type FunctionArtifact } from '@aztec/foundation/abi';
+import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
+import { Fr, FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
+import type { FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
 
 import { witnessMapToFields } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
 import { type ClientExecutionContext } from './client_execution_context.js';
 import { type ExecutionResult } from './execution_result.js';
-import { AcirSimulator } from './simulator.js';
 
 /**
  * Execute a private function and return the execution result.
@@ -17,37 +18,51 @@ export async function executePrivateFunction(
   context: ClientExecutionContext,
   artifact: FunctionArtifact,
   contractAddress: AztecAddress,
-  functionData: FunctionData,
+  functionSelector: FunctionSelector,
   log = createDebugLogger('aztec:simulator:secret_execution'),
 ): Promise<ExecutionResult> {
-  const functionSelector = functionData.selector;
-  log.verbose(`Executing external function ${contractAddress}:${functionSelector}(${artifact.name})`);
+  const functionName = await context.getDebugFunctionName();
+  log.verbose(`Executing external function ${contractAddress}:${functionSelector}(${functionName})`);
   const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);
-  const acirExecutionResult = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch(
-    (err: Error) => {
-      throw new ExecutionError(
-        err.message,
-        {
-          contractAddress,
-          functionSelector,
-        },
-        extractCallStack(err, artifact.debug),
-        { cause: err },
-      );
-    },
-  );
+  const timer = new Timer();
+  const acirExecutionResult = await acvm(acir, initialWitness, acvmCallback).catch((err: Error) => {
+    throw new ExecutionError(
+      err.message,
+      {
+        contractAddress,
+        functionSelector,
+      },
+      extractCallStack(err, artifact.debug),
+      { cause: err },
+    );
+  });
+  const duration = timer.ms();
   const partialWitness = acirExecutionResult.partialWitness;
   const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
   const publicInputs = PrivateCircuitPublicInputs.fromFields(returnWitness);
 
-  context.chopNoteEncryptedLogs();
+  // TODO (alexg) estimate this size
+  const initialWitnessSize = witnessMapToFields(initialWitness).length * Fr.SIZE_IN_BYTES;
+  log.debug(`Ran external function ${contractAddress.toString()}:${functionSelector}`, {
+    circuitName: 'app-circuit',
+    duration,
+    eventName: 'circuit-witness-generation',
+    inputSize: initialWitnessSize,
+    outputSize: publicInputs.toBuffer().length,
+    appCircuitName: functionName,
+  } satisfies CircuitWitnessGenerationStats);
+
   const noteEncryptedLogs = context.getNoteEncryptedLogs();
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
 
-  const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);
+  const callStackItem = new PrivateCallStackItem(
+    contractAddress,
+    new FunctionData(functionSelector, true),
+    publicInputs,
+  );
 
   const rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
 

package/src/client/simulator.ts

@@ -1,5 +1,5 @@
 import { type AztecNode, type FunctionCall, type Note, type TxExecutionRequest } from '@aztec/circuit-types';
-import { CallContext, FunctionData } from '@aztec/circuits.js';
+import { CallContext } from '@aztec/circuits.js';
 import {
   type ArrayType,
   type FunctionArtifact,
@@ -11,8 +11,6 @@ import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
-import { type WasmBlackBoxFunctionSolver, createBlackBoxSolver } from '@noir-lang/acvm_js';
-
 import { createSimulationError } from '../common/errors.js';
 import { PackedValuesCache } from '../common/packed_values_cache.js';
 import { ClientExecutionContext } from './client_execution_context.js';
@@ -27,33 +25,12 @@ import { ViewDataOracle } from './view_data_oracle.js';
  * The ACIR simulator.
  */
 export class AcirSimulator {
-  private static solver: Promise<WasmBlackBoxFunctionSolver>; // ACVM's backend
   private log: DebugLogger;
 
   constructor(private db: DBOracle, private node: AztecNode) {
     this.log = createDebugLogger('aztec:simulator');
   }
 
-  /**
-   * Gets or initializes the ACVM WasmBlackBoxFunctionSolver.
-   *
-   * @remarks
-   *
-   * Occurs only once across all instances of AcirSimulator.
-   * Speeds up execution by only performing setup tasks (like pedersen
-   * generator initialization) one time.
-   * TODO(https://github.com/AztecProtocol/aztec-packages/issues/1627):
-   * determine whether this requires a lock
-   *
-   * @returns ACVM WasmBlackBoxFunctionSolver
-   */
-  public static getSolver(): Promise<WasmBlackBoxFunctionSolver> {
-    if (!this.solver) {
-      this.solver = createBlackBoxSolver();
-    }
-    return this.solver;
-  }
-
   /**
    * Runs a private function.
    * @param request - The transaction request.
@@ -110,7 +87,7 @@ export class AcirSimulator {
         context,
         entryPointArtifact,
         contractAddress,
-        request.functionData,
+        request.functionSelector,
       );
       return executionResult;
     } catch (err) {
@@ -141,7 +118,7 @@ export class AcirSimulator {
         context,
         entryPointArtifact,
         contractAddress,
-        request.functionData,
+        request.selector,
         request.args,
       );
     } catch (err) {
@@ -155,29 +132,31 @@ export class AcirSimulator {
    * @param nonce - The nonce of the note hash.
    * @param storageSlot - The storage slot.
    * @param noteTypeId - The note type identifier.
+   * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
    * @param note - The note.
    * @returns The nullifier.
    */
-  public async computeNoteHashAndNullifier(
+  public async computeNoteHashAndOptionallyANullifier(
     contractAddress: AztecAddress,
     nonce: Fr,
     storageSlot: Fr,
     noteTypeId: Fr,
+    computeNullifier: boolean,
     note: Note,
   ) {
     const artifact: FunctionArtifact | undefined = await this.db.getFunctionArtifactByName(
       contractAddress,
-      'compute_note_hash_and_nullifier',
+      'compute_note_hash_and_optionally_a_nullifier',
     );
     if (!artifact) {
       throw new Error(
-        `Mandatory implementation of "compute_note_hash_and_nullifier" missing in noir contract ${contractAddress.toString()}.`,
+        `Mandatory implementation of "compute_note_hash_and_optionally_a_nullifier" missing in noir contract ${contractAddress.toString()}.`,
       );
     }
 
-    if (artifact.parameters.length != 5) {
+    if (artifact.parameters.length != 6) {
       throw new Error(
-        `Expected 5 parameters in mandatory implementation of "compute_note_hash_and_nullifier", but found ${
+        `Expected 6 parameters in mandatory implementation of "compute_note_hash_and_optionally_a_nullifier", but found ${
           artifact.parameters.length
         } in noir contract ${contractAddress.toString()}.`,
       );
@@ -186,17 +165,27 @@ export class AcirSimulator {
     const maxNoteFields = (artifact.parameters[artifact.parameters.length - 1].type as ArrayType).length;
     if (maxNoteFields < note.items.length) {
       throw new Error(
-        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
+        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_optionally_a_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
       );
     }
 
     const extendedNoteItems = note.items.concat(Array(maxNoteFields - note.items.length).fill(Fr.ZERO));
 
     const execRequest: FunctionCall = {
+      name: artifact.name,
       to: contractAddress,
-      functionData: FunctionData.empty(),
+      selector: FunctionSelector.empty(),
+      type: FunctionType.UNCONSTRAINED,
       isStatic: artifact.isStatic,
-      args: encodeArguments(artifact, [contractAddress, nonce, storageSlot, noteTypeId, extendedNoteItems]),
+      args: encodeArguments(artifact, [
+        contractAddress,
+        nonce,
+        storageSlot,
+        noteTypeId,
+        computeNullifier,
+        extendedNoteItems,
+      ]),
+      returnTypes: artifact.returnTypes,
     };
 
     const [innerNoteHash, uniqueNoteHash, siloedNoteHash, innerNullifier] = (await this.runUnconstrained(
@@ -222,11 +211,12 @@ export class AcirSimulator {
    * @returns The note hash.
    */
   public async computeInnerNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: Fr, note: Note) {
-    const { innerNoteHash } = await this.computeNoteHashAndNullifier(
+    const { innerNoteHash } = await this.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       Fr.ZERO,
       storageSlot,
       noteTypeId,
+      false,
       note,
     );
     return innerNoteHash;

package/src/client/unconstrained_execution.ts

@@ -1,5 +1,9 @@
-import { type FunctionData } from '@aztec/circuits.js';
-import { type DecodedReturn, type FunctionArtifact, decodeReturnValues } from '@aztec/foundation/abi';
+import {
+  type DecodedReturn,
+  type FunctionArtifact,
+  type FunctionSelector,
+  decodeReturnValues,
+} from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -7,7 +11,6 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { witnessMapToFields } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack, toACVMWitness } from '../acvm/index.js';
 import { ExecutionError } from '../common/errors.js';
-import { AcirSimulator } from './simulator.js';
 import { type ViewDataOracle } from './view_data_oracle.js';
 
 // docs:start:execute_unconstrained_function
@@ -18,21 +21,15 @@ export async function executeUnconstrainedFunction(
   oracle: ViewDataOracle,
   artifact: FunctionArtifact,
   contractAddress: AztecAddress,
-  functionData: FunctionData,
+  functionSelector: FunctionSelector,
   args: Fr[],
   log = createDebugLogger('aztec:simulator:unconstrained_execution'),
 ): Promise<DecodedReturn> {
-  const functionSelector = functionData.selector;
   log.verbose(`Executing unconstrained function ${contractAddress}:${functionSelector}(${artifact.name})`);
 
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
-  const acirExecutionResult = await acvm(
-    await AcirSimulator.getSolver(),
-    acir,
-    initialWitness,
-    new Oracle(oracle),
-  ).catch((err: Error) => {
+  const acirExecutionResult = await acvm(acir, initialWitness, new Oracle(oracle)).catch((err: Error) => {
     throw new ExecutionError(
       err.message,
       {
@@ -45,6 +42,6 @@ export async function executeUnconstrainedFunction(
   });
 
   const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-  return decodeReturnValues(artifact, returnWitness);
+  return decodeReturnValues(artifact.returnTypes, returnWitness);
 }
 // docs:end:execute_unconstrained_function

package/src/client/view_data_oracle.ts

@@ -34,6 +34,14 @@ export class ViewDataOracle extends TypedOracle {
     super();
   }
 
+  public override getBlockNumber(): Promise<number> {
+    return this.aztecNode.getBlockNumber();
+  }
+
+  public override getContractAddress(): Promise<AztecAddress> {
+    return Promise.resolve(this.contractAddress);
+  }
+
   /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.

package/src/index.ts

@@ -1,7 +1,9 @@
 export * from './acvm/index.js';
+export * from './avm/index.js';
 export * from './client/index.js';
 export * from './common/index.js';
 export * from './public/index.js';
-export * from './simulator/index.js';
+export * from './providers/index.js';
 export * from './mocks/index.js';
 export * from './stats/index.js';
+export * from './utils.js';

package/src/mocks/fixtures.ts

@@ -1,18 +1,17 @@
 import { type FunctionCall, type SimulationError, UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
   ARGS_LENGTH,
+  AvmExecutionHints,
   type AztecAddress,
   CallContext,
-  CallRequest,
+  type ContractStorageRead,
   type ContractStorageUpdateRequest,
   Fr,
-  FunctionData,
   Gas,
-  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  type PrivateKernelTailCircuitPublicInputs,
   type PublicCallRequest,
 } from '@aztec/circuits.js';
 import { makeAztecAddress, makeSelector } from '@aztec/circuits.js/testing';
+import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
 import { type PublicExecution, type PublicExecutionResult } from '../public/execution.js';
@@ -21,6 +20,7 @@ export class PublicExecutionResultBuilder {
   private _execution: PublicExecution;
   private _nestedExecutions: PublicExecutionResult[] = [];
   private _contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
+  private _contractStorageReads: ContractStorageRead[] = [];
   private _returnValues: Fr[] = [];
   private _reverted = false;
   private _revertReason: SimulationError | undefined = undefined;
@@ -34,17 +34,25 @@ export class PublicExecutionResultBuilder {
     returnValues = [new Fr(1n)],
     nestedExecutions = [],
     contractStorageUpdateRequests = [],
+    contractStorageReads = [],
+    revertReason = undefined,
   }: {
     request: PublicCallRequest;
     returnValues?: Fr[];
     nestedExecutions?: PublicExecutionResult[];
     contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
+    contractStorageReads?: ContractStorageRead[];
+    revertReason?: SimulationError;
   }): PublicExecutionResultBuilder {
     const builder = new PublicExecutionResultBuilder(request);
 
     builder.withNestedExecutions(...nestedExecutions);
     builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
+    builder.withContractStorageRead(...contractStorageReads);
     builder.withReturnValues(...returnValues);
+    if (revertReason) {
+      builder.withReverted(revertReason);
+    }
 
     return builder;
   }
@@ -55,6 +63,7 @@ export class PublicExecutionResultBuilder {
     returnValues = [new Fr(1n)],
     nestedExecutions = [],
     contractStorageUpdateRequests = [],
+    contractStorageReads = [],
     revertReason,
   }: {
     from: AztecAddress;
@@ -62,17 +71,19 @@ export class PublicExecutionResultBuilder {
     returnValues?: Fr[];
     nestedExecutions?: PublicExecutionResult[];
     contractStorageUpdateRequests?: ContractStorageUpdateRequest[];
+    contractStorageReads?: ContractStorageRead[];
     revertReason?: SimulationError;
   }) {
     const builder = new PublicExecutionResultBuilder({
-      callContext: new CallContext(from, tx.to, tx.functionData.selector, false, false, 0),
+      callContext: new CallContext(from, tx.to, tx.selector, false, false, 0),
       contractAddress: tx.to,
-      functionData: tx.functionData,
+      functionSelector: tx.selector,
       args: tx.args,
     });
 
     builder.withNestedExecutions(...nestedExecutions);
     builder.withContractStorageUpdateRequest(...contractStorageUpdateRequests);
+    builder.withContractStorageRead(...contractStorageReads);
     builder.withReturnValues(...returnValues);
     if (revertReason) {
       builder.withReverted(revertReason);
@@ -91,6 +102,11 @@ export class PublicExecutionResultBuilder {
     return this;
   }
 
+  withContractStorageRead(...reads: ContractStorageRead[]): PublicExecutionResultBuilder {
+    this._contractStorageReads.push(...reads);
+    return this;
+  }
+
   withReturnValues(...values: Fr[]): PublicExecutionResultBuilder {
     this._returnValues.push(...values);
     return this;
@@ -106,8 +122,10 @@ export class PublicExecutionResultBuilder {
     return {
       execution: this._execution,
       nestedExecutions: this._nestedExecutions,
+      noteHashReadRequests: [],
       nullifierReadRequests: [],
       nullifierNonExistentReadRequests: [],
+      l1ToL2MsgReadRequests: [],
       contractStorageUpdateRequests: this._contractStorageUpdateRequests,
       returnValues: padArrayEnd(this._returnValues, Fr.ZERO, 4), // TODO(#5450) Need to use the proper return values here
       newNoteHashes: [],
@@ -124,39 +142,19 @@ export class PublicExecutionResultBuilder {
       startGasLeft: Gas.test(),
       endGasLeft: Gas.test(),
       transactionFee: Fr.ZERO,
+      calldata: [],
+      avmHints: AvmExecutionHints.empty(),
       ...overrides,
     };
   }
 }
 
 export const makeFunctionCall = (
+  name = 'function',
   to = makeAztecAddress(30),
   selector = makeSelector(5),
+  type = FunctionType.PUBLIC,
   args = new Array(ARGS_LENGTH).fill(Fr.ZERO),
   isStatic = false,
-) => ({ to, functionData: new FunctionData(selector, /*isPrivate=*/ false), args, isStatic });
-
-export function addKernelPublicCallStack(
-  kernelOutput: PrivateKernelTailCircuitPublicInputs,
-  calls: {
-    setupCalls: PublicCallRequest[];
-    appLogicCalls: PublicCallRequest[];
-    teardownCall: PublicCallRequest;
-  },
-) {
-  // the first two calls are non-revertible
-  // the first is for setup, the second is for teardown
-  kernelOutput.forPublic!.endNonRevertibleData.publicCallStack = padArrayEnd(
-    // this is a stack, so the first item is the last call
-    // and callRequests is in the order of the calls
-    [calls.teardownCall.toCallRequest(), ...calls.setupCalls.map(c => c.toCallRequest())],
-    CallRequest.empty(),
-    MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  );
-
-  kernelOutput.forPublic!.end.publicCallStack = padArrayEnd(
-    calls.appLogicCalls.map(c => c.toCallRequest()),
-    CallRequest.empty(),
-    MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  );
-}
+  returnTypes = [],
+) => ({ name, to, selector, type, args, isStatic, returnTypes });

package/src/{simulator → providers}/acvm_native.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from '@aztec/foundation/crypto';
+import { runInDirectory } from '@aztec/foundation/fs';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
@@ -137,23 +137,25 @@ export class NativeACVMSimulator implements SimulationProvider {
   async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
     // 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');
-
-    // Provide a unique working directory so we don't get clashes with parallel executions
-    const directory = `${this.workingDirectory}/${randomBytes(8).toString('hex')}`;
-
-    await fs.mkdir(directory, { recursive: true });
-
-    // Execute the circuit
-    const result = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm, this.witnessFilename);
-
-    await fs.rm(directory, { force: true, recursive: true });
-
-    if (result.status == ACVM_RESULT.FAILURE) {
-      throw new Error(`Failed to generate witness: ${result.reason}`);
-    }
-
-    return result.witness;
+    const operation = async (directory: string) => {
+      // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+      const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+      // Execute the circuit
+      const result = await executeNativeCircuit(
+        input,
+        decodedBytecode,
+        directory,
+        this.pathToAcvm,
+        this.witnessFilename,
+      );
+
+      if (result.status == ACVM_RESULT.FAILURE) {
+        throw new Error(`Failed to generate witness: ${result.reason}`);
+      }
+
+      return result.witness;
+    };
+
+    return await runInDirectory(this.workingDirectory, operation);
   }
 }

package/src/{simulator → providers}/acvm_wasm.ts

@@ -1,24 +1,11 @@
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
-import {
-  type WasmBlackBoxFunctionSolver,
-  createBlackBoxSolver,
-  executeCircuitWithBlackBoxSolver,
-} from '@noir-lang/acvm_js';
+import { executeCircuit } from '@noir-lang/acvm_js';
 import { type WitnessMap } from '@noir-lang/types';
 
 import { type SimulationProvider } from './simulation_provider.js';
 
-let solver: Promise<WasmBlackBoxFunctionSolver>;
-
-const getSolver = (): Promise<WasmBlackBoxFunctionSolver> => {
-  if (!solver) {
-    solver = createBlackBoxSolver();
-  }
-  return solver;
-};
-
 export class WASMSimulator implements SimulationProvider {
   async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
     // Execute the circuit on those initial witness values
@@ -27,8 +14,7 @@ export class WASMSimulator implements SimulationProvider {
     const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuitWithBlackBoxSolver(
-      await getSolver(),
+    const _witnessMap = await executeCircuit(
       decodedBytecode,
       input,
       foreignCallHandler, // handle calls to debug_log