@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.5daedc8

package/src/common/errors.ts

@@ -1,6 +1,15 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import type { BrilligFunctionId, FunctionAbi, FunctionDebugMetadata, OpcodeLocation } from '@aztec/stdlib/abi';
+import type { RawAssertionPayload } from '@aztec/noir-acvm_js';
+import { abiDecodeError } from '@aztec/noir-noirc_abi';
+import type {
+  BrilligFunctionId,
+  DebugFileMap,
+  DebugInfo,
+  FunctionAbi,
+  LocationNodeDebugInfo,
+  OpcodeLocation,
+} from '@aztec/stdlib/abi';
 import {
   type FailingFunction,
   type NoirCallStack,
@@ -8,9 +17,6 @@ import {
   type SourceCodeLocation,
 } from '@aztec/stdlib/errors';
 
-import type { RawAssertionPayload } from '@noir-lang/acvm_js';
-import { abiDecodeError } from '@noir-lang/noirc_abi';
-
 /**
  * An error that occurred during the execution of a function.
  * @param message - the error message
@@ -77,38 +83,42 @@ export function createSimulationError(error: Error, revertData?: Fr[]): Simulati
 }
 
 /**
- * Extracts a brillig location from an opcode location.
- * @param opcodeLocation - The opcode location to extract from. It should be in the format `acirLocation.brilligLocation` or `acirLocation`.
- * @returns The brillig location if the opcode location contains one.
- */
-function extractBrilligLocation(opcodeLocation: string): string | undefined {
-  const splitted = opcodeLocation.split('.');
-  if (splitted.length === 2) {
-    return splitted[1];
-  }
-  return undefined;
-}
-
-/**
- * Extracts the call stack from the location of a failing opcode and the debug metadata.
- * One opcode can point to multiple calls due to inlining.
+ * Resolves the source code locations from an array of opcode locations
  */
-function getSourceCodeLocationsFromOpcodeLocation(
-  opcodeLocation: string,
-  debug: FunctionDebugMetadata,
+export function resolveOpcodeLocations(
+  opcodeLocations: OpcodeLocation[],
+  debug: DebugInfo,
+  files: DebugFileMap,
   brilligFunctionId?: BrilligFunctionId,
 ): SourceCodeLocation[] {
-  const { debugSymbols, files } = debug;
+  let locations = opcodeLocations.flatMap(opcodeLocation =>
+    getSourceCodeLocationsFromOpcodeLocation(opcodeLocation, debug, files, brilligFunctionId),
+  );
 
-  let callStack = debugSymbols.locations[opcodeLocation] || [];
-  if (callStack.length === 0) {
-    const brilligLocation = extractBrilligLocation(opcodeLocation);
-    if (brilligFunctionId !== undefined && brilligLocation !== undefined) {
-      callStack = debugSymbols.brillig_locations[brilligFunctionId][brilligLocation] || [];
+  // Adds the acir call stack if the last location is a brillig opcode
+  if (locations.length > 0) {
+    const decomposedOpcodeLocation = opcodeLocations[opcodeLocations.length - 1].split('.');
+    if (decomposedOpcodeLocation.length === 2) {
+      const acirCallstackId = debug.acir_locations[decomposedOpcodeLocation[0]];
+      if (acirCallstackId !== undefined) {
+        const callStack = debug.location_tree.locations[acirCallstackId];
+        const acirCallstack = getCallStackFromLocationNode(callStack, debug.location_tree.locations, files);
+        locations = acirCallstack.concat(locations);
+      }
     }
   }
-  return callStack.map(call => {
-    const { file: fileId, span } = call;
+  return locations;
+}
+
+function getCallStackFromLocationNode(
+  callStack: LocationNodeDebugInfo,
+  locationTree: LocationNodeDebugInfo[],
+  files: DebugFileMap,
+): SourceCodeLocation[] {
+  const result: SourceCodeLocation[] = [];
+
+  while (callStack.parent !== null) {
+    const { file: fileId, span } = callStack.value;
 
     const { path, source } = files[fileId];
 
@@ -119,30 +129,55 @@ function getSourceCodeLocationsFromOpcodeLocation(
     const line = previousLines.length;
     const column = previousLines[previousLines.length - 1].length + 1;
 
-    return {
+    // Unshift since we are exploring child nodes first
+    result.unshift({
       filePath: path,
       line,
       column,
       fileSource: source,
       locationText,
-    };
-  });
-}
+    });
 
+    callStack = locationTree[callStack.parent];
+  }
+
+  return result;
+}
 /**
- * Extracts the source code locations for an array of opcode locations
- * @param opcodeLocations - The opcode locations that caused the error.
- * @param debug - The debug metadata of the function.
- * @returns The source code locations.
+ * Extracts the call stack from the location of a failing opcode and the debug metadata.
+ * One opcode can point to multiple calls due to inlining.
  */
-export function resolveOpcodeLocations(
-  opcodeLocations: OpcodeLocation[],
-  debug: FunctionDebugMetadata,
+function getSourceCodeLocationsFromOpcodeLocation(
+  opcodeLocation: string,
+  debug: DebugInfo,
+  files: DebugFileMap,
   brilligFunctionId?: BrilligFunctionId,
 ): SourceCodeLocation[] {
-  return opcodeLocations.flatMap(opcodeLocation =>
-    getSourceCodeLocationsFromOpcodeLocation(opcodeLocation, debug, brilligFunctionId),
-  );
+  let callStackID = debug.acir_locations[opcodeLocation];
+  const brilligLocation = extractBrilligLocation(opcodeLocation);
+  if (brilligFunctionId !== undefined && brilligLocation !== undefined) {
+    callStackID = debug.brillig_locations[brilligFunctionId][brilligLocation];
+    if (callStackID === undefined) {
+      return [];
+    }
+  }
+
+  if (callStackID === undefined) {
+    return [];
+  }
+  const callStack = debug.location_tree.locations[callStackID];
+  return getCallStackFromLocationNode(callStack, debug.location_tree.locations, files);
+}
+
+/**
+ * Extracts a brillig location from an opcode location.
+ */
+function extractBrilligLocation(opcodeLocation: string): string | undefined {
+  const splitted = opcodeLocation.split('.');
+  if (splitted.length === 2) {
+    return splitted[1];
+  }
+  return undefined;
 }
 
 export function resolveAssertionMessage(errorPayload: RawAssertionPayload, abi: FunctionAbi): string | undefined {

package/src/common/index.ts

@@ -1,3 +1,2 @@
 export * from './errors.js';
 export * from './stats/index.js';
-export * from './message_load_oracle_inputs.js';

package/src/private/acvm/acvm.ts

@@ -1,33 +1,22 @@
 import { createLogger } from '@aztec/foundation/log';
-import type { FunctionDebugMetadata } from '@aztec/stdlib/abi';
-import type { NoirCallStack } from '@aztec/stdlib/errors';
-
 import {
   type ExecutionError,
   type ForeignCallInput,
   type ForeignCallOutput,
   executeCircuitWithReturnWitness,
-} from '@noir-lang/acvm_js';
+} from '@aztec/noir-acvm_js';
+import type { FunctionDebugMetadata } from '@aztec/stdlib/abi';
+import type { NoirCallStack } from '@aztec/stdlib/errors';
 
 import { resolveOpcodeLocations, traverseCauseChain } from '../../common/errors.js';
 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[]
-  ) =>
-    | void
-    | Promise<void>
-    | ForeignCallOutput
-    | ForeignCallOutput[]
-    | Promise<ForeignCallOutput>
-    | Promise<ForeignCallOutput[]>
->;
+export type ACIRCallback = Record<string, (...args: ForeignCallInput[]) => Promise<ForeignCallOutput[]>>;
+
+export type ACIRCallbackStats = { times: number[] };
 
 /**
  * The result of executing an ACIR.
@@ -40,10 +29,16 @@ export interface ACIRExecutionResult {
    */
   partialWitness: ACVMWitness;
   returnWitness: ACVMWitness;
+  oracles?: Record<string, ACIRCallbackStats>;
 }
 
 /**
  * The function call that executes an ACIR.
+ * @param acir - The ACIR circuit bytecode to execute.
+ * @param initialWitness - The initial witness map defining all of the inputs to `circuit`.
+ * @param callback - A callback to process any foreign calls from the circuit.
+ * @returns The solved witness calculated by executing the circuit on the provided inputs, as well as the return
+ * witness indices as specified by the circuit.
  */
 export async function acvm(
   acir: Buffer,
@@ -55,25 +50,15 @@ export async function acvm(
   const solvedAndReturnWitness = await executeCircuitWithReturnWitness(
     acir,
     initialWitness,
-    async (name: string, args: ForeignCallInput[]) => {
+    (name: string, args: ForeignCallInput[]) => {
       try {
         logger.debug(`Oracle callback ${name}`);
-        const oracleFunction = callback[name as ORACLE_NAMES];
+        const oracleFunction = callback[name];
         if (!oracleFunction) {
           throw new Error(`Oracle callback ${name} not found`);
         }
 
-        const result = await oracleFunction.call(callback, ...args);
-
-        if (typeof result === 'undefined') {
-          return [];
-        } else if (result instanceof Array && !result.every(item => typeof item === 'string')) {
-          // We are dealing with a nested array which means that we do not need it wrap it in another array as to have
-          // the nested array structure it is already "wrapped".
-          return result;
-        } else {
-          return [result] as ForeignCallOutput[];
-        }
+        return oracleFunction.call(callback, ...args);
       } catch (err) {
         let typedError: Error;
         if (err instanceof Error) {
@@ -120,8 +105,8 @@ export function extractCallStack(
   }
 
   try {
-    return resolveOpcodeLocations(callStack, debug, brilligFunctionId);
-  } catch (err) {
+    return resolveOpcodeLocations(callStack, debug.debugSymbols, debug.files, brilligFunctionId);
+  } catch {
     return callStack;
   }
 }

package/src/private/acvm/acvm_types.ts

@@ -1,4 +1,4 @@
-import type { WitnessMap } from '@noir-lang/acvm_js';
+import type { WitnessMap } from '@aztec/noir-acvm_js';
 
 /**
  * ACVMField

package/src/private/acvm/deserialize.ts

@@ -1,34 +1,8 @@
 import { Fr } from '@aztec/foundation/fields';
+import { hexToBuffer } from '@aztec/foundation/string';
 
 import type { ACVMField, ACVMWitness } from './acvm_types.js';
 
-/**
- * Converts an ACVM field to a Fr.
- * @param field - The ACVM field to convert.
- * @returns The Fr.
- */
-export function fromACVMField(field: ACVMField): Fr {
-  return Fr.fromBuffer(Buffer.from(field.slice(2), 'hex'));
-}
-
-/**
- * Converts a field to a number.
- * @param fr - The field to convert.
- * @returns The number.
- * TODO(#4102): Nuke this once block number is big int.
- */
-export function frToNumber(fr: Fr): number {
-  return Number(fr.value);
-}
-
-/**
- * Converts a field to a boolean.
- * @param fr - The field to convert.
- */
-export function frToBoolean(fr: Fr): boolean {
-  return fr.toBigInt() === BigInt(1);
-}
-
 /**
  * Converts a Noir BoundedVec of Fields into an Fr array. Note that BoundedVecs are structs, and therefore translated as
  * two separate ACVMField values (an array and a single field).
@@ -38,7 +12,25 @@ export function frToBoolean(fr: Fr): boolean {
  * @returns An array with the same content as the Noir version. Elements past the length are discarded.
  */
 export function fromBoundedVec(storage: ACVMField[], length: ACVMField): Fr[] {
-  return storage.slice(0, frToNumber(fromACVMField(length))).map(fromACVMField);
+  return storage.slice(0, Fr.fromString(length).toNumber()).map(Fr.fromString);
+}
+
+/**
+ * Converts a Noir BoundedVec of unsigned integers into a Buffer. Note that BoundedVecs are structs, and therefore
+ * translated as two separate ACVMField values (an array and a single field).
+ *
+ * @param storage The array with the BoundedVec's storage (i.e. BoundedVec::storage())
+ * @param length The length of the BoundedVec (i.e. BoundedVec::len())
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer containing the unsigned integers tightly packed
+ */
+export function fromUintBoundedVec(storage: ACVMField[], length: ACVMField, uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  const boundedStorage = storage.slice(0, Fr.fromString(length).toNumber());
+  return Buffer.concat(boundedStorage.map(str => hexToBuffer(str).subarray(-uintByteSize)));
 }
 
 /**
@@ -48,5 +40,19 @@ export function fromBoundedVec(storage: ACVMField[], length: ACVMField): Fr[] {
  */
 export function witnessMapToFields(witness: ACVMWitness): Fr[] {
   const sortedKeys = [...witness.keys()].sort((a, b) => a - b);
-  return sortedKeys.map(key => witness.get(key)!).map(fromACVMField);
+  return sortedKeys.map(key => witness.get(key)!).map(Fr.fromString);
+}
+
+/**
+ * Converts an array of Noir unsigned integers to a single tightly-packed buffer.
+ * @param uintBitSize If it's an array of Noir u8's, put `8`, etc.
+ * @returns A buffer where each byte is correctly represented as a single byte in the buffer.
+ * Copy of the function in txe/src/util/encoding.ts.
+ */
+export function fromUintArray(obj: ACVMField[], uintBitSize: number): Buffer {
+  if (uintBitSize % 8 !== 0) {
+    throw new Error(`u${uintBitSize} is not a supported type in Noir`);
+  }
+  const uintByteSize = uintBitSize / 8;
+  return Buffer.concat(obj.map(str => hexToBuffer(str).slice(-uintByteSize)));
 }

package/src/private/acvm/index.ts

@@ -1,5 +1,4 @@
 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';

package/src/private/acvm/serialize.ts

@@ -58,3 +58,66 @@ export function toACVMWitness(witnessStartIndex: number, fields: Parameters<type
     return witness;
   }, new Map<number, ACVMField>());
 }
+
+export function bufferToU8Array(buffer: Buffer): ACVMField[] {
+  return Array.from(buffer).map(byte => toACVMField(BigInt(byte)));
+}
+
+export function bufferToBoundedVec(buffer: Buffer, maxLen: number): [ACVMField[], ACVMField] {
+  const u8Array = bufferToU8Array(buffer);
+  return arrayToBoundedVec(u8Array, maxLen);
+}
+
+/**
+ * Converts a ForeignCallArray into a tuple which represents a nr BoundedVec.
+ * If the input array is shorter than the maxLen, it pads the result with zeros,
+ * so that nr can correctly coerce this result into a BoundedVec.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - the max length of the BoundedVec.
+ * @returns a tuple representing a BoundedVec.
+ */
+export function arrayToBoundedVec(bVecStorage: ACVMField[], maxLen: number): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+  const lengthDiff = maxLen - bVecStorage.length;
+  const zeroPaddingArray = Array(lengthDiff).fill(toACVMField(BigInt(0)));
+  const storage = bVecStorage.concat(zeroPaddingArray);
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [storage, len];
+}
+
+/**
+ * Converts an array of arrays representing Noir BoundedVec of nested arrays into its Noir serialized form.
+ * @param bVecStorage - The array underlying the BoundedVec.
+ * @param maxLen - The max length of the BoundedVec (max num of the nested arrays in the BoundedVec).
+ * @param nestedArrayLength - The length of the nested arrays (each nested array has to have the same length).
+ * @returns Serialized BoundedVec following Noir intrinsic serialization.
+ */
+export function arrayOfArraysToBoundedVecOfArrays(
+  bVecStorage: ACVMField[][],
+  maxLen: number,
+  nestedArrayLength: number,
+): [ACVMField[], ACVMField] {
+  if (bVecStorage.length > maxLen) {
+    throw new Error(`Array of length ${bVecStorage.length} larger than maxLen ${maxLen}`);
+  }
+
+  // Check that all nested arrays have length nestedArrayLength
+  if (!bVecStorage.every(nestedArray => nestedArray.length === nestedArrayLength)) {
+    throw new Error(
+      `Nested array length passed in from Noir does not correspond to the length obtained in TS: ${nestedArrayLength} !== ${bVecStorage[0].length}`,
+    );
+  }
+
+  // Flatten the array of arrays
+  const flattenedStorage = bVecStorage.flat();
+
+  // Calculate and add padding
+  const numFieldsToPad = maxLen * nestedArrayLength - flattenedStorage.length;
+  const flattenedStorageWithPadding = flattenedStorage.concat(Array(numFieldsToPad).fill(toACVMField(BigInt(0))));
+
+  // Return flattened array with padding and length
+  const len = toACVMField(BigInt(bVecStorage.length));
+  return [flattenedStorageWithPadding, len];
+}

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

@@ -1,15 +1,16 @@
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { ForeignCallHandler, WitnessMap } from '@aztec/noir-acvm_js';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
-import type { WitnessMap } from '@noir-lang/types';
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
 
-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';
 
 const logger = createLogger('simulator:acvm-native');
 
@@ -76,7 +77,7 @@ export async function executeNativeCircuit(
   try {
     // Check that the directory exists
     await fs.access(workingDirectory);
-  } catch (error) {
+  } catch {
     return { status: ACVM_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
   }
 
@@ -102,46 +103,68 @@ export async function executeNativeCircuit(
     logger.debug(`Calling ACVM with ${args.join(' ')}`);
 
     const processPromise = new Promise<string>((resolve, reject) => {
-      let outputWitness = Buffer.alloc(0);
-      let errorBuffer = Buffer.alloc(0);
+      const outChunks: Buffer[] = [];
+      const errChunks: Buffer[] = [];
+      let outLen = 0;
+      let errLen = 0;
       const acvm = proc.spawn(pathToAcvm, args);
-      acvm.stdout.on('data', data => {
-        outputWitness = Buffer.concat([outputWitness, data]);
+      acvm.stdout.on('data', (data: Buffer) => {
+        outChunks.push(data);
+        outLen += data.length;
       });
-      acvm.stderr.on('data', data => {
-        errorBuffer = Buffer.concat([errorBuffer, data]);
+      acvm.stderr.on('data', (data: Buffer) => {
+        errChunks.push(data);
+        errLen += data.length;
       });
       acvm.on('close', code => {
         if (code === 0) {
-          resolve(outputWitness.toString('utf-8'));
+          resolve(Buffer.concat(outChunks, outLen).toString('utf-8'));
         } else {
-          logger.error(`From ACVM: ${errorBuffer.toString('utf-8')}`);
-          reject(errorBuffer.toString('utf-8'));
+          const stderr = Buffer.concat(errChunks, errLen);
+          logger.error(`From ACVM: ${stderr.toString('utf-8')}`);
+          reject(stderr.toString('utf-8'));
         }
       });
     });
 
-    const duration = new Timer();
+    const timer = new Timer();
     const output = await processPromise;
+    const duration = timer.ms();
     if (outputFilename) {
       const outputWitnessFileName = `${workingDirectory}/output-witness.gz`;
       await fs.copyFile(outputWitnessFileName, outputFilename);
     }
+    // TODO: We shouldn't be parsing the witness from stdout, it's not very performant, and we end up with two ways of fetching the witness.
+    // We probably should implement the WitnessStack type, run the ACVM with msgpack serialization mode (env variable), and ungzip and parse the witness from
+    // the outputted gz witness file.
     const witness = parseIntoWitnessMap(output);
-    return { status: ACVM_RESULT.SUCCESS, witness, duration: duration.ms() };
+    return { status: ACVM_RESULT.SUCCESS, witness, duration };
   } catch (error) {
     return { status: ACVM_RESULT.FAILURE, reason: `${error}` };
   }
 }
 
-export class NativeACVMSimulator implements SimulationProvider {
-  constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+export class NativeACVMSimulator implements CircuitSimulator {
+  constructor(
+    private workingDirectory: string,
+    private pathToAcvm: string,
+    private witnessFilename?: string,
+  ) {}
+
+  async executeProtocolCircuit(
+    input: ACVMWitness,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler | undefined,
+  ): Promise<ACVMSuccess> {
     // Execute the circuit on those initial witness values
 
+    if (callback) {
+      throw new Error('Native ACVM simulator does not support foreign calls. Ignoring callback.');
+    }
+
     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');
+      const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
       // Execute the circuit
       const result = await executeNativeCircuit(
         input,
@@ -155,15 +178,15 @@ export class NativeACVMSimulator implements SimulationProvider {
         throw new Error(`Failed to generate witness: ${result.reason}`);
       }
 
-      return result.witness;
+      return result;
     };
 
     return await runInDirectory(this.workingDirectory, operation, false, logger);
   }
 
   executeUserCircuit(
-    _acir: Buffer,
-    _initialWitness: ACVMWitness,
+    _input: ACVMWitness,
+    _artifact: FunctionArtifactWithContractName,
     _callback: ACIRCallback,
   ): Promise<ACIRExecutionResult> {
     throw new Error('Not implemented');

package/src/private/acvm_wasm.ts

@@ -0,0 +1,72 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import initACVM, { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
+import initAbi from '@aztec/noir-noirc_abi';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
+
+import { type ACIRCallback, type ACIRExecutionResult, acvm } from './acvm/acvm.js';
+import type { ACVMWitness } from './acvm/acvm_types.js';
+import type { ACVMSuccess } from './acvm_native.js';
+import { type CircuitSimulator, enrichNoirError } from './circuit_simulator.js';
+
+export class WASMSimulator implements CircuitSimulator {
+  constructor(protected log = createLogger('wasm-simulator')) {}
+
+  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: ACVMWitness,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler,
+  ): Promise<ACVMSuccess> {
+    this.log.debug('init', { hash: artifact.hash });
+    await this.init();
+
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
+    //
+    // Execute the circuit
+    try {
+      const timer = new Timer();
+      const result = await executeCircuit(
+        decodedBytecode,
+        input,
+        callback, // handle calls to debug_log
+      );
+      this.log.debug('execution successful', { hash: artifact.hash });
+      return { witness: result, duration: timer.ms() } as ACVMSuccess;
+    } catch (err) {
+      // Typescript types caught errors as unknown or any, so we need to narrow its type to check if it has raw
+      // assertion payload.
+      if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
+        const parsed = enrichNoirError(artifact, err as ExecutionError);
+        this.log.debug('execution failed', {
+          hash: artifact.hash,
+          error: parsed,
+          message: parsed.message,
+        });
+        throw parsed;
+      }
+      this.log.debug('execution failed', { hash: artifact.hash, error: err });
+      throw new Error(`Circuit execution failed: ${err}`);
+    }
+  }
+
+  async executeUserCircuit(
+    input: ACVMWitness,
+    artifact: FunctionArtifactWithContractName,
+    callback: ACIRCallback,
+  ): Promise<ACIRExecutionResult> {
+    await this.init();
+    return acvm(artifact.bytecode, input, callback);
+  }
+}