@aztec/simulator 0.69.1-devnet → 0.70.0

package/src/client/execution_note_cache.ts

@@ -25,32 +25,55 @@ export class ExecutionNoteCache {
   private noteMap: Map<bigint, PendingNote[]> = new Map();
 
   /**
-   * The list of nullifiers created in this transaction.
-   * This mapping maps from a contract address to the nullifiers emitted from the contract.
+   * This maps from a contract address to the nullifiers emitted from the contract.
    * The note which is nullified might be new or not (i.e., was generated in a previous transaction).
    * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
    */
   private nullifierMap: Map<bigint, Set<bigint>> = new Map();
 
+  /**
+   * All nullifiers emitted in this transaction.
+   */
+  private allNullifiers: Set<bigint> = new Set();
+
   private minRevertibleSideEffectCounter = 0;
 
-  constructor(private readonly txHash: Fr) {}
+  private inRevertiblePhase = false;
+
+  /**
+   * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
+   * In that case we disable injecting the tx request hash as a nullifier.
+   */
+  private usedTxRequestHashForNonces = true;
 
+  constructor(private readonly txRequestHash: Fr) {}
+
+  /**
+   * Enters the revertible phase of the transaction.
+   * @param minRevertibleSideEffectCounter - The counter at which the transaction enters the revertible phase.
+   */
   public setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
-    if (this.minRevertibleSideEffectCounter && this.minRevertibleSideEffectCounter !== minRevertibleSideEffectCounter) {
+    if (this.inRevertiblePhase) {
       throw new Error(
-        `Cannot override minRevertibleSideEffectCounter. Current value: ${minRevertibleSideEffectCounter}. Previous value: ${this.minRevertibleSideEffectCounter}`,
+        `Cannot enter the revertible phase twice. Current counter: ${minRevertibleSideEffectCounter}. Previous enter counter: ${this.minRevertibleSideEffectCounter}`,
       );
     }
-
+    this.inRevertiblePhase = true;
     this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
 
+    let nonceGenerator = this.txRequestHash;
+    const nullifiers = this.getAllNullifiers();
+    if (nullifiers.length > 0) {
+      nonceGenerator = new Fr(nullifiers[0]);
+      this.usedTxRequestHashForNonces = false;
+    }
+
     // The existing pending notes are all non-revertible.
     // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
     // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
     // The nonces will be used to create the "complete" nullifier.
     const updatedNotes = this.notes.map(({ note, counter }, i) => {
-      const nonce = computeNoteHashNonce(this.txHash, i);
+      const nonce = computeNoteHashNonce(nonceGenerator, i);
       const uniqueNoteHash = computeUniqueNoteHash(nonce, siloNoteHash(note.contractAddress, note.noteHash));
       return {
         counter,
@@ -64,6 +87,17 @@ export class ExecutionNoteCache {
     updatedNotes.forEach(n => this.#addNote(n));
   }
 
+  public finish() {
+    // If we never entered the revertible phase, we need to use the tx request hash as a nonce for the notes if no nullifiers have been emitted.
+    if (!this.inRevertiblePhase) {
+      this.usedTxRequestHashForNonces = this.getAllNullifiers().length === 0;
+    }
+    // If we entered the revertible phase, the nonce generator was decided based on wether or not a nullifier was emitted before entering.
+    return {
+      usedTxRequestHashForNonces: this.usedTxRequestHashForNonces,
+    };
+  }
+
   /**
    * Add a new note to cache.
    * @param note - New note created during execution.
@@ -88,10 +122,6 @@ export class ExecutionNoteCache {
    */
   public nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr) {
     const siloedNullifier = siloNullifier(contractAddress, innerNullifier);
-    const nullifiers = this.getNullifiers(contractAddress);
-    nullifiers.add(siloedNullifier.value);
-    this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
-
     let nullifiedNoteHashCounter: number | undefined = undefined;
     // Find and remove the matching new note and log(s) if the emitted noteHash is not empty.
     if (!noteHash.isEmpty()) {
@@ -105,10 +135,28 @@ export class ExecutionNoteCache {
       nullifiedNoteHashCounter = note.counter;
       this.noteMap.set(contractAddress.toBigInt(), notesInContract);
       this.notes = this.notes.filter(n => n.counter !== note.counter);
+
+      // If the note is non revertible and the nullifier was emitted in the revertible phase, both the note hash and the nullifier will be emitted
+      if (this.inRevertiblePhase && note.counter < this.minRevertibleSideEffectCounter) {
+        this.recordNullifier(contractAddress, siloedNullifier);
+      }
+    } else {
+      // If the note being nullified comes from a previous tx the nullifier will be emitted.
+      this.recordNullifier(contractAddress, siloedNullifier);
     }
     return nullifiedNoteHashCounter;
   }
 
+  /**
+   * Adds a nullifier to the cache. Note cache needs to track all nullifiers to decide which nullifier to use for note siloing.
+   * @param contractAddress - Contract address that emitted the nullifier.
+   * @param innerNullifier
+   */
+  public nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
+    const siloedNullifier = siloNullifier(contractAddress, innerNullifier);
+    this.recordNullifier(contractAddress, siloedNullifier);
+  }
+
   /**
    * Return notes created up to current point in execution.
    * If a nullifier for a note in this list is emitted, the note will be deleted.
@@ -152,8 +200,13 @@ export class ExecutionNoteCache {
   }
 
   getAllNullifiers(): Fr[] {
-    return [...this.nullifierMap.values()].flatMap(nullifierArray =>
-      [...nullifierArray.values()].map(val => new Fr(val)),
-    );
+    return [...this.allNullifiers].map(n => new Fr(n));
+  }
+
+  recordNullifier(contractAddress: AztecAddress, siloedNullifier: Fr) {
+    const nullifiers = this.getNullifiers(contractAddress);
+    nullifiers.add(siloedNullifier.toBigInt());
+    this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
+    this.allNullifiers.add(siloedNullifier.toBigInt());
   }
 }

package/src/client/index.ts

@@ -1,6 +1,14 @@
-export * from './simulator.js';
-export * from './db_oracle.js';
+export { AcirSimulator } from './simulator.js';
+export { DBOracle, ContractClassNotFoundError, ContractNotFoundError } from './db_oracle.js';
 export * from './pick_notes.js';
-export * from './execution_note_cache.js';
+export { ExecutionNoteCache } from './execution_note_cache.js';
 export { extractPrivateCircuitPublicInputs } from './private_execution.js';
+export { witnessMapToFields } from '../acvm/deserialize.js';
+export { toACVMWitness } from '../acvm/serialize.js';
+export { extractCallStack } from '../acvm/acvm.js';
 export { WASMSimulator } from '../providers/acvm_wasm.js';
+export { NoteData, TypedOracle } from '../acvm/oracle/typed_oracle.js';
+export { Oracle } from '../acvm/oracle/oracle.js';
+export { type SimulationProvider } from '../common/simulation_provider.js';
+export { MessageLoadOracleInputs } from '../common/message_load_oracle_inputs.js';
+export { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '../common/errors.js';

package/src/client/private_execution.ts

@@ -1,4 +1,4 @@
-import { PrivateExecutionResult } from '@aztec/circuit-types';
+import { PrivateCallExecutionResult } from '@aztec/circuit-types';
 import { type CircuitWitnessGenerationStats } from '@aztec/circuit-types/stats';
 import {
   Fr,
@@ -12,38 +12,42 @@ import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 
 import { fromACVMField, witnessMapToFields } from '../acvm/deserialize.js';
-import { type ACVMWitness, Oracle, acvm, extractCallStack } from '../acvm/index.js';
+import { type ACVMWitness, Oracle, extractCallStack } from '../acvm/index.js';
 import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
+import { type SimulationProvider } from '../server.js';
 import { type ClientExecutionContext } from './client_execution_context.js';
 
 /**
  * Execute a private function and return the execution result.
  */
 export async function executePrivateFunction(
+  simulator: SimulationProvider,
   context: ClientExecutionContext,
   artifact: FunctionArtifact,
   contractAddress: AztecAddress,
   functionSelector: FunctionSelector,
   log = createLogger('simulator:private_execution'),
-): Promise<PrivateExecutionResult> {
+): Promise<PrivateCallExecutionResult> {
   const functionName = await context.getDebugFunctionName();
   log.verbose(`Executing private function ${functionName}@${contractAddress}`);
   const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);
   const timer = new Timer();
-  const acirExecutionResult = await acvm(acir, initialWitness, acvmCallback).catch((err: Error) => {
-    err.message = resolveAssertionMessageFromError(err, artifact);
-    throw new ExecutionError(
-      err.message,
-      {
-        contractAddress,
-        functionSelector,
-      },
-      extractCallStack(err, artifact.debug),
-      { cause: err },
-    );
-  });
+  const acirExecutionResult = await simulator
+    .executeUserCircuit(acir, initialWitness, acvmCallback)
+    .catch((err: Error) => {
+      err.message = resolveAssertionMessageFromError(err, artifact);
+      throw new ExecutionError(
+        err.message,
+        {
+          contractAddress,
+          functionSelector,
+        },
+        extractCallStack(err, artifact.debug),
+        { cause: err },
+      );
+    });
   const duration = timer.ms();
   const partialWitness = acirExecutionResult.partialWitness;
   const publicInputs = extractPrivateCircuitPublicInputs(artifact, partialWitness);
@@ -61,7 +65,7 @@ export async function executePrivateFunction(
 
   const contractClassLogs = context.getContractClassLogs();
 
-  const rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
+  const rawReturnValues = await context.loadFromExecutionCache(publicInputs.returnsHash);
 
   const noteHashLeafIndexMap = context.getNoteHashLeafIndexMap();
   const newNotes = context.getNewNotes();
@@ -72,7 +76,7 @@ export async function executePrivateFunction(
 
   log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
-  return new PrivateExecutionResult(
+  return new PrivateCallExecutionResult(
     acir,
     Buffer.from(artifact.verificationKey!, 'base64'),
     partialWitness,

package/src/client/simulator.ts

@@ -1,4 +1,10 @@
-import type { AztecNode, FunctionCall, Note, PrivateExecutionResult, TxExecutionRequest } from '@aztec/circuit-types';
+import {
+  type AztecNode,
+  type FunctionCall,
+  type Note,
+  PrivateExecutionResult,
+  type TxExecutionRequest,
+} from '@aztec/circuit-types';
 import { CallContext } from '@aztec/circuits.js';
 import {
   type ArrayType,
@@ -13,7 +19,8 @@ import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 
 import { createSimulationError } from '../common/errors.js';
-import { PackedValuesCache } from '../common/packed_values_cache.js';
+import { HashedValuesCache } from '../common/hashed_values_cache.js';
+import { type SimulationProvider } from '../common/simulation_provider.js';
 import { ClientExecutionContext } from './client_execution_context.js';
 import { type DBOracle } from './db_oracle.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
@@ -27,7 +34,7 @@ import { ViewDataOracle } from './view_data_oracle.js';
 export class AcirSimulator {
   private log: Logger;
 
-  constructor(private db: DBOracle, private node: AztecNode) {
+  constructor(private db: DBOracle, private node: AztecNode, private simulationProvider: SimulationProvider) {
     this.log = createLogger('simulator');
   }
 
@@ -69,7 +76,8 @@ export class AcirSimulator {
       entryPointArtifact.isStatic,
     );
 
-    const txHash = request.toTxRequest().hash();
+    const txRequestHash = request.toTxRequest().hash();
+    const noteCache = new ExecutionNoteCache(txRequestHash);
 
     const context = new ClientExecutionContext(
       request.firstCallArgsHash,
@@ -77,10 +85,11 @@ export class AcirSimulator {
       callContext,
       header,
       request.authWitnesses,
-      PackedValuesCache.create(request.argsOfCalls),
-      new ExecutionNoteCache(txHash),
+      HashedValuesCache.create(request.argsOfCalls),
+      noteCache,
       this.db,
       this.node,
+      this.simulationProvider,
       startSideEffectCounter,
       undefined,
       scopes,
@@ -88,12 +97,15 @@ export class AcirSimulator {
 
     try {
       const executionResult = await executePrivateFunction(
+        this.simulationProvider,
         context,
         entryPointArtifact,
         contractAddress,
         request.functionSelector,
       );
-      return executionResult;
+      const { usedTxRequestHashForNonces } = noteCache.finish();
+      const firstNullifierHint = usedTxRequestHashForNonces ? Fr.ZERO : noteCache.getAllNullifiers()[0];
+      return new PrivateExecutionResult(executionResult, firstNullifierHint);
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
@@ -120,6 +132,7 @@ export class AcirSimulator {
 
     try {
       return await executeUnconstrainedFunction(
+        this.simulationProvider,
         context,
         entryPointArtifact,
         contractAddress,

package/src/client/unconstrained_execution.ts

@@ -4,8 +4,9 @@ import { type Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 
 import { witnessMapToFields } from '../acvm/deserialize.js';
-import { Oracle, acvm, extractCallStack, toACVMWitness } from '../acvm/index.js';
+import { Oracle, extractCallStack, toACVMWitness } from '../acvm/index.js';
 import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
+import { type SimulationProvider } from '../server.js';
 import { type ViewDataOracle } from './view_data_oracle.js';
 
 // docs:start:execute_unconstrained_function
@@ -13,6 +14,7 @@ import { type ViewDataOracle } from './view_data_oracle.js';
  * Execute an unconstrained function and return the decoded values.
  */
 export async function executeUnconstrainedFunction(
+  simulatorProvider: SimulationProvider,
   oracle: ViewDataOracle,
   artifact: FunctionArtifact,
   contractAddress: AztecAddress,
@@ -24,18 +26,20 @@ export async function executeUnconstrainedFunction(
 
   const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
-  const acirExecutionResult = await acvm(acir, initialWitness, new Oracle(oracle)).catch((err: Error) => {
-    err.message = resolveAssertionMessageFromError(err, artifact);
-    throw new ExecutionError(
-      err.message,
-      {
-        contractAddress,
-        functionSelector,
-      },
-      extractCallStack(err, artifact.debug),
-      { cause: err },
-    );
-  });
+  const acirExecutionResult = await simulatorProvider
+    .executeUserCircuit(acir, initialWitness, new Oracle(oracle))
+    .catch((err: Error) => {
+      err.message = resolveAssertionMessageFromError(err, artifact);
+      throw new ExecutionError(
+        err.message,
+        {
+          contractAddress,
+          functionSelector,
+        },
+        extractCallStack(err, artifact.debug),
+        { cause: err },
+      );
+    });
 
   const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
   return decodeFromAbi(artifact.returnTypes, returnWitness);

package/src/common/hashed_values_cache.ts

@@ -0,0 +1,55 @@
+import { HashedValues } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+
+/**
+ * A cache for hashed values (arguments, returns) during transaction execution.
+ */
+export class HashedValuesCache {
+  private cache: Map<bigint, Fr[]>;
+
+  constructor(initialArguments: HashedValues[] = []) {
+    this.cache = new Map();
+    for (const initialArg of initialArguments) {
+      this.cache.set(initialArg.hash.toBigInt(), initialArg.values);
+    }
+  }
+
+  /**
+   * Creates a new hashed values cache.
+   * @param initialArguments - The initial arguments to add to the cache.
+   * @returns The new hashed values cache.
+   */
+  public static create(initialArguments: HashedValues[] = []) {
+    return new HashedValuesCache(initialArguments);
+  }
+
+  /**
+   * Gets preimage of a hash.
+   * @param hash - The hash to get the preimage of.
+   * @returns The preimage.
+   */
+  public getPreimage(hash: Fr): Fr[] {
+    if (hash.equals(Fr.ZERO)) {
+      return [];
+    }
+    const hashedValues = this.cache.get(hash.value);
+    if (!hashedValues) {
+      throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
+    }
+    return hashedValues;
+  }
+
+  /**
+   * Stores values in cache and returns its hash.
+   * @param values - The values to store.
+   * @returns The hash of the values.
+   */
+  public store(values: Fr[]) {
+    if (values.length === 0) {
+      return Fr.ZERO;
+    }
+    const hashedValues = HashedValues.fromValues(values);
+    this.cache.set(hashedValues.hash.value, hashedValues.values);
+    return hashedValues.hash;
+  }
+}

package/src/common/index.ts

@@ -1,2 +1,2 @@
-export * from './packed_values_cache.js';
+export * from './hashed_values_cache.js';
 export * from './errors.js';

package/src/common/message_load_oracle_inputs.ts

@@ -0,0 +1,15 @@
+import { type SiblingPath } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+
+export class MessageLoadOracleInputs<N extends number> {
+  constructor(
+    /** The index of the message commitment in the merkle tree. */
+    public index: bigint,
+    /** The path in the merkle tree to the message. */
+    public siblingPath: SiblingPath<N>,
+  ) {}
+
+  toFields(): Fr[] {
+    return [new Fr(this.index), ...this.siblingPath.toFields()];
+  }
+}

package/src/common/simulation_provider.ts

@@ -0,0 +1,45 @@
+import { type NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { type ExecutionError } from '@noir-lang/acvm_js';
+import { abiDecodeError } from '@noir-lang/noirc_abi';
+import { type Abi, type WitnessMap } from '@noir-lang/types';
+
+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>;
+}
+
+export type ErrorWithPayload = ExecutionError & { decodedAssertionPayload?: any };
+
+// Error handling taken from noir/noir-repo/tooling/noir_js/src/witness_generation.ts.
+// TODO: import this in isolation without having to import noir_js in its entirety.
+export function parseErrorPayload(abi: Abi, originalError: ExecutionError): Error {
+  const payload = originalError.rawAssertionPayload;
+  if (!payload) {
+    return originalError;
+  }
+  const enrichedError = originalError as ErrorWithPayload;
+
+  try {
+    // Decode the payload
+    const decodedPayload = abiDecodeError(abi, payload);
+
+    if (typeof decodedPayload === 'string') {
+      // If it's a string, just add it to the error message
+      enrichedError.message = `Circuit execution failed: ${decodedPayload}`;
+    } else {
+      // If not, attach the payload to the original error
+      enrichedError.decodedAssertionPayload = decodedPayload;
+    }
+  } catch (_errorDecoding) {
+    // Ignore errors decoding the payload
+  }
+
+  return enrichedError;
+}

package/src/common.ts

@@ -0,0 +1 @@
+export * from './common/index.js';

package/src/providers/acvm_native.ts

@@ -7,7 +7,9 @@ import { type WitnessMap } from '@noir-lang/types';
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
 
-import { type SimulationProvider } from './simulation_provider.js';
+import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
+import { type ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider } from '../common/simulation_provider.js';
 
 const logger = createLogger('simulator:acvm-native');
 
@@ -134,7 +136,7 @@ export async function executeNativeCircuit(
 
 export class NativeACVMSimulator implements SimulationProvider {
   constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
-  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
     // Execute the circuit on those initial witness values
 
     const operation = async (directory: string) => {
@@ -158,4 +160,12 @@ export class NativeACVMSimulator implements SimulationProvider {
 
     return await runInDirectory(this.workingDirectory, operation, false);
   }
+
+  executeUserCircuit(
+    _acir: Buffer,
+    _initialWitness: ACVMWitness,
+    _callback: ACIRCallback,
+  ): Promise<ACIRExecutionResult> {
+    throw new Error('Not implemented');
+  }
 }

package/src/providers/acvm_wasm.ts

@@ -1,25 +1,52 @@
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
-import { executeCircuit } from '@noir-lang/acvm_js';
+import initACVM, { type ExecutionError, executeCircuit } from '@noir-lang/acvm_js';
+import initAbi from '@noir-lang/noirc_abi';
 import { type WitnessMap } from '@noir-lang/types';
 
-import { type SimulationProvider } from './simulation_provider.js';
+import { type ACIRCallback, acvm } from '../acvm/acvm.js';
+import { type ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider, parseErrorPayload } from '../common/simulation_provider.js';
 
 export class WASMSimulator implements SimulationProvider {
-  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+  async init(): Promise<void> {
+    // If these are available, then we are in the
+    // web environment. For the node environment, this
+    // is a no-op.
+    if (typeof initAbi === 'function') {
+      /** @ts-expect-error The node bundle doesn't include these default imports, so TS complains */
+      await Promise.all([initAbi(), initACVM()]);
+    }
+  }
+
+  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    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');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuit(
-      decodedBytecode,
-      input,
-      foreignCallHandler, // handle calls to debug_log
-    );
+    try {
+      const _witnessMap = await executeCircuit(
+        decodedBytecode,
+        input,
+        foreignCallHandler, // handle calls to debug_log
+      );
+
+      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.
+      if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+        throw parseErrorPayload(compiledCircuit.abi, err as ExecutionError);
+      }
+      throw new Error(`Circuit execution failed: ${err}`);
+    }
+  }
 
-    return _witnessMap;
+  async executeUserCircuit(acir: Buffer, initialWitness: ACVMWitness, callback: ACIRCallback) {
+    await this.init();
+    return acvm(acir, initialWitness, callback);
   }
 }

package/src/providers/acvm_wasm_with_blobs.ts

@@ -1,25 +1,50 @@
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
-import { executeCircuit } from '@noir-lang/acvm_js';
+import { type ExecutionError, executeCircuit } from '@noir-lang/acvm_js';
 import { type WitnessMap } from '@noir-lang/types';
 
-import { type SimulationProvider } from './simulation_provider.js';
+import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
+import { type ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider, parseErrorPayload } from '../common/simulation_provider.js';
 
+/**
+ * A simulation provider 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 class WASMSimulatorWithBlobs implements SimulationProvider {
-  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+  async executeProtocolCircuit(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');
     //
     // Execute the circuit
-    const _witnessMap = await executeCircuit(
-      decodedBytecode,
-      input,
-      foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
-    );
+    try {
+      const _witnessMap = await executeCircuit(
+        decodedBytecode,
+        input,
+        foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
+      );
 
-    return _witnessMap;
+      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.
+      if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+        throw parseErrorPayload(compiledCircuit.abi, err as ExecutionError);
+      }
+      throw new Error(`Circuit execution failed: ${err}`);
+    }
+  }
+
+  executeUserCircuit(
+    _acir: Buffer,
+    _initialWitness: ACVMWitness,
+    _callback: ACIRCallback,
+  ): Promise<ACIRExecutionResult> {
+    throw new Error('Not implemented');
   }
 }

package/src/providers/factory.ts

@@ -2,9 +2,9 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 
 import { promises as fs } from 'fs';
 
+import { type SimulationProvider } from '../common/simulation_provider.js';
 import { NativeACVMSimulator } from './acvm_native.js';
 import { WASMSimulator } from './acvm_wasm.js';
-import { type SimulationProvider } from './simulation_provider.js';
 
 export type SimulationProviderConfig = {
   acvmBinaryPath?: string;