@aztec/simulator 0.81.0 → 0.82.1-alpha-testnet.1

package/src/private/hashed_values_cache.ts

@@ -28,15 +28,12 @@ export class HashedValuesCache {
    * @param hash - The hash to get the preimage of.
    * @returns The preimage.
    */
-  public getPreimage(hash: Fr): Fr[] {
-    if (hash.equals(Fr.ZERO)) {
+  public getPreimage(hash: Fr): Fr[] | undefined {
+    if (hash.isEmpty()) {
       return [];
+    } else {
+      return this.cache.get(hash.toBigInt());
     }
-    const hashedValues = this.cache.get(hash.toBigInt());
-    if (!hashedValues) {
-      throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
-    }
-    return hashedValues;
   }
 
   /**
@@ -44,12 +41,7 @@ export class HashedValuesCache {
    * @param values - The values to store.
    * @returns The hash of the values.
    */
-  public async store(values: Fr[]) {
-    if (values.length === 0) {
-      return Fr.ZERO;
-    }
-    const hashedValues = await HashedValues.fromValues(values);
-    this.cache.set(hashedValues.hash.toBigInt(), hashedValues.values);
-    return hashedValues.hash;
+  public store(values: Fr[], hash: Fr) {
+    this.cache.set(hash.toBigInt(), values);
   }
 }

package/src/private/private_execution.ts

@@ -3,7 +3,12 @@ import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { type FunctionArtifact, type FunctionSelector, countArgumentsSize } from '@aztec/stdlib/abi';
+import {
+  type FunctionArtifact,
+  type FunctionArtifactWithContractName,
+  type FunctionSelector,
+  countArgumentsSize,
+} from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractInstance } from '@aztec/stdlib/contract';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
@@ -13,7 +18,7 @@ import type { CircuitWitnessGenerationStats } from '@aztec/stdlib/stats';
 import { PrivateCallExecutionResult } from '@aztec/stdlib/tx';
 
 import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
-import { fromACVMField, witnessMapToFields } from './acvm/deserialize.js';
+import { witnessMapToFields } from './acvm/deserialize.js';
 import { type ACVMWitness, Oracle, extractCallStack } from './acvm/index.js';
 import type { ExecutionDataProvider } from './execution_data_provider.js';
 import type { PrivateExecutionOracle } from './private_execution_oracle.js';
@@ -25,19 +30,18 @@ import type { SimulationProvider } from './providers/simulation_provider.js';
 export async function executePrivateFunction(
   simulator: SimulationProvider,
   privateExecutionOracle: PrivateExecutionOracle,
-  artifact: FunctionArtifact,
+  artifact: FunctionArtifactWithContractName,
   contractAddress: AztecAddress,
   functionSelector: FunctionSelector,
   log = createLogger('simulator:private_execution'),
 ): Promise<PrivateCallExecutionResult> {
   const functionName = await privateExecutionOracle.getDebugFunctionName();
   log.verbose(`Executing private function ${functionName}`, { contract: contractAddress });
-  const acir = artifact.bytecode;
   const initialWitness = privateExecutionOracle.getInitialWitness(artifact);
   const acvmCallback = new Oracle(privateExecutionOracle);
   const timer = new Timer();
   const acirExecutionResult = await simulator
-    .executeUserCircuit(acir, initialWitness, acvmCallback)
+    .executeUserCircuit(initialWitness, artifact, acvmCallback)
     .catch((err: Error) => {
       err.message = resolveAssertionMessageFromError(err, artifact);
       throw new ExecutionError(
@@ -73,13 +77,11 @@ export async function executePrivateFunction(
   const newNotes = privateExecutionOracle.getNewNotes();
   const noteHashNullifierCounterMap = privateExecutionOracle.getNoteHashNullifierCounterMap();
   const nestedExecutions = privateExecutionOracle.getNestedExecutions();
-  const enqueuedPublicFunctionCalls = privateExecutionOracle.getEnqueuedPublicFunctionCalls();
-  const publicTeardownFunctionCall = privateExecutionOracle.getPublicTeardownFunctionCall();
 
   log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
   return new PrivateCallExecutionResult(
-    acir,
+    artifact.bytecode,
     Buffer.from(artifact.verificationKey!, 'base64'),
     partialWitness,
     publicInputs,
@@ -88,8 +90,6 @@ export async function executePrivateFunction(
     noteHashNullifierCounterMap,
     rawReturnValues,
     nestedExecutions,
-    enqueuedPublicFunctionCalls,
-    publicTeardownFunctionCall,
     contractClassLogs,
   );
 }
@@ -113,7 +113,7 @@ export function extractPrivateCircuitPublicInputs(
     if (returnedField === undefined) {
       throw new Error(`Missing return value for index ${i}`);
     }
-    returnData.push(fromACVMField(returnedField));
+    returnData.push(Fr.fromString(returnedField));
   }
   return PrivateCircuitPublicInputs.fromFields(returnData);
 }

package/src/private/private_execution_oracle.ts

@@ -1,8 +1,4 @@
-import {
-  MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS,
-  PRIVATE_CONTEXT_INPUTS_LENGTH,
-  PUBLIC_DISPATCH_SELECTOR,
-} from '@aztec/constants';
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS, PRIVATE_CONTEXT_INPUTS_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import {
@@ -23,10 +19,8 @@ import {
   CallContext,
   Capsule,
   CountedContractClassLog,
-  CountedPublicExecutionRequest,
   NoteAndSlot,
   PrivateCallExecutionResult,
-  PublicExecutionRequest,
   type TxContext,
 } from '@aztec/stdlib/tx';
 
@@ -64,8 +58,6 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
   private noteHashNullifierCounterMap: Map<number, number> = new Map();
   private contractClassLogs: CountedContractClassLog[] = [];
   private nestedExecutions: PrivateCallExecutionResult[] = [];
-  private enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[] = [];
-  private publicTeardownFunctionCall: PublicExecutionRequest = PublicExecutionRequest.empty();
 
   constructor(
     private readonly argsHash: Fr,
@@ -80,7 +72,7 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     private readonly noteCache: ExecutionNoteCache,
     executionDataProvider: ExecutionDataProvider,
     private provider: SimulationProvider,
-    private totalPublicArgsCount: number,
+    private totalPublicCalldataCount: number,
     protected sideEffectCounter: number = 0,
     log = createLogger('simulator:client_execution_context'),
     scopes?: AztecAddress[],
@@ -100,8 +92,8 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
 
     const args = this.executionCache.getPreimage(this.argsHash);
 
-    if (args.length !== argumentsSize) {
-      throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args.length}`);
+    if (args?.length !== argumentsSize) {
+      throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args?.length}`);
     }
 
     const privateContextInputs = new PrivateContextInputs(
@@ -152,27 +144,13 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     return this.nestedExecutions;
   }
 
-  /**
-   * Return the enqueued public function calls during this execution.
-   */
-  public getEnqueuedPublicFunctionCalls() {
-    return this.enqueuedPublicFunctionCalls;
-  }
-
-  /**
-   * Return the public teardown function call set during this execution.
-   */
-  public getPublicTeardownFunctionCall() {
-    return this.publicTeardownFunctionCall;
-  }
-
   /**
    * Store values in the execution cache.
    * @param values - Values to store.
    * @returns The hash of the values.
    */
-  public override storeInExecutionCache(values: Fr[]): Promise<Fr> {
-    return this.executionCache.store(values);
+  public override storeInExecutionCache(values: Fr[], hash: Fr) {
+    return this.executionCache.store(values, hash);
   }
 
   /**
@@ -181,7 +159,11 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
    * @returns The values.
    */
   public override loadFromExecutionCache(hash: Fr): Promise<Fr[]> {
-    return Promise.resolve(this.executionCache.getPreimage(hash));
+    const preimage = this.executionCache.getPreimage(hash);
+    if (!preimage) {
+      throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
+    }
+    return Promise.resolve(preimage);
   }
 
   /**
@@ -413,7 +395,7 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
       this.noteCache,
       this.executionDataProvider,
       this.provider,
-      this.totalPublicArgsCount,
+      this.totalPublicCalldataCount,
       sideEffectCounter,
       this.log,
       this.scopes,
@@ -440,131 +422,50 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     };
   }
 
-  /**
-   * Creates a PublicExecutionRequest object representing the request to call a public function.
-   * @param targetContractAddress - The address of the contract to call.
-   * @param functionSelector - The function selector of the function to call.
-   * @param argsHash - The arguments hash to pass to the function.
-   * @param sideEffectCounter - The side effect counter at the start of the call.
-   * @param isStaticCall - Whether the call is a static call.
-   * @returns The public call stack item with the request information.
-   */
-  protected async createPublicExecutionRequest(
-    callType: 'enqueued' | 'teardown',
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ) {
-    const targetArtifact = await this.executionDataProvider.getFunctionArtifact(
-      targetContractAddress,
-      functionSelector,
-    );
-    const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
-    const args = this.executionCache.getPreimage(argsHash);
-
-    this.log.verbose(
-      `Created ${callType} public execution request to ${targetArtifact.name}@${targetContractAddress}`,
-      {
-        sideEffectCounter,
-        isStaticCall,
-        functionSelector,
-        targetContractAddress,
-        callType,
-      },
-    );
-
-    const request = PublicExecutionRequest.from({
-      args,
-      callContext: derivedCallContext,
-    });
+  #onNewPublicFunctionCall(calldataHash: Fr) {
+    const calldata = this.executionCache.getPreimage(calldataHash);
+    if (!calldata) {
+      throw new Error('Calldata for public call not found in cache');
+    }
 
-    if (callType === 'enqueued') {
-      this.enqueuedPublicFunctionCalls.push(new CountedPublicExecutionRequest(request, sideEffectCounter));
-    } else {
-      this.publicTeardownFunctionCall = request;
+    this.totalPublicCalldataCount += calldata.length;
+    if (this.totalPublicCalldataCount > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
+      throw new Error(`Too many total args to all enqueued public calls! (> ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS})`);
     }
   }
 
   /**
-   * Creates and enqueues a PublicExecutionRequest object representing the request to call a public function. No function
-   * is actually called, since that must happen on the sequencer side. All the fields related to the result
-   * of the execution are empty.
+   * Verify relevant information when a public function is enqueued.
    * @param targetContractAddress - The address of the contract to call.
-   * @param functionSelector - The function selector of the function to call.
-   * @param argsHash - The arguments hash to pass to the function.
+   * @param calldataHash - The hash of the function selector and arguments.
    * @param sideEffectCounter - The side effect counter at the start of the call.
    * @param isStaticCall - Whether the call is a static call.
-   * @returns The public call stack item with the request information.
    */
-  public override async enqueuePublicFunctionCall(
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ): Promise<Fr> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
-    // WARNING: This is insecure and should be temporary!
-    // The oracle re-hashes the arguments and returns a new args_hash.
-    // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
-    // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
-    // b) this is only temporary.
-    const newArgs = [functionSelector.toField(), ...this.executionCache.getPreimage(argsHash)];
-    const newArgsHash = await this.executionCache.store(newArgs);
-    await this.createPublicExecutionRequest(
-      'enqueued',
-      targetContractAddress,
-      FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-      newArgsHash,
-      sideEffectCounter,
-      isStaticCall,
-    );
-    this.totalPublicArgsCount += newArgs.length;
-    if (this.totalPublicArgsCount > MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS) {
-      throw new Error(`Too many total args to all enqueued public calls! (> ${MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS})`);
-    }
-    return newArgsHash;
+  public override notifyEnqueuedPublicFunctionCall(
+    _targetContractAddress: AztecAddress,
+    calldataHash: Fr,
+    _sideEffectCounter: number,
+    _isStaticCall: boolean,
+  ) {
+    this.#onNewPublicFunctionCall(calldataHash);
+    return Promise.resolve();
   }
 
   /**
-   * Creates a PublicExecutionRequest and sets it as the public teardown function. No function
-   * is actually called, since that must happen on the sequencer side. All the fields related to the result
-   * of the execution are empty.
+   * Verify relevant information when a public teardown function is set.
    * @param targetContractAddress - The address of the contract to call.
-   * @param functionSelector - The function selector of the function to call.
    * @param argsHash - The arguments hash to pass to the function.
    * @param sideEffectCounter - The side effect counter at the start of the call.
    * @param isStaticCall - Whether the call is a static call.
-   * @returns The public call stack item with the request information.
    */
-  public override async setPublicTeardownFunctionCall(
-    targetContractAddress: AztecAddress,
-    functionSelector: FunctionSelector,
-    argsHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ): Promise<Fr> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
-    // WARNING: This is insecure and should be temporary!
-    // The oracle rehashes the arguments and returns a new args_hash.
-    // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
-    // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
-    // b) this is only temporary.
-    const newArgsHash = await this.executionCache.store([
-      functionSelector.toField(),
-      ...this.executionCache.getPreimage(argsHash),
-    ]);
-    await this.createPublicExecutionRequest(
-      'teardown',
-      targetContractAddress,
-      FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-      newArgsHash,
-      sideEffectCounter,
-      isStaticCall,
-    );
-    return newArgsHash;
+  public override notifySetPublicTeardownFunctionCall(
+    _targetContractAddress: AztecAddress,
+    calldataHash: Fr,
+    _sideEffectCounter: number,
+    _isStaticCall: boolean,
+  ) {
+    this.#onNewPublicFunctionCall(calldataHash);
+    return Promise.resolve();
   }
 
   public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void> {

package/src/private/providers/acvm_native.ts

@@ -1,8 +1,10 @@
 import { runInDirectory } from '@aztec/foundation/fs';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { WitnessMap } from '@aztec/noir-acvm_js';
+import type { ForeignCallHandler } from '@aztec/noir-protocol-circuits-types/types';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
 import * as proc from 'child_process';
 import { promises as fs } from 'fs';
@@ -136,12 +138,21 @@ export async function executeNativeCircuit(
 
 export class NativeACVMSimulator implements SimulationProvider {
   constructor(private workingDirectory: string, private pathToAcvm: string, private witnessFilename?: string) {}
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+
+  async executeProtocolCircuit(
+    input: ACVMWitness,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler | undefined,
+  ): Promise<ACVMWitness> {
     // 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,
@@ -162,8 +173,8 @@ export class NativeACVMSimulator implements SimulationProvider {
   }
 
   executeUserCircuit(
-    _acir: Buffer,
-    _initialWitness: ACVMWitness,
+    _input: ACVMWitness,
+    _artifact: FunctionArtifactWithContractName,
     _callback: ACIRCallback,
   ): Promise<ACIRExecutionResult> {
     throw new Error('Not implemented');

package/src/private/providers/acvm_wasm.ts

@@ -1,11 +1,10 @@
 import { createLogger } from '@aztec/foundation/log';
-import initACVM, { type ExecutionError, executeCircuit } from '@aztec/noir-acvm_js';
+import initACVM, { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import initAbi from '@aztec/noir-noirc_abi';
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
-import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
-import { type ACIRCallback, acvm } from '../acvm/acvm.js';
+import { type ACIRCallback, type ACIRExecutionResult, acvm } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
 import { type SimulationProvider, enrichNoirError } from './simulation_provider.js';
 
@@ -22,41 +21,49 @@ export class WASMSimulator implements SimulationProvider {
     }
   }
 
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
-    this.log.debug('init', { hash: compiledCircuit.hash });
+  async executeProtocolCircuit(
+    input: ACVMWitness,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler,
+  ): Promise<ACVMWitness> {
+    this.log.debug('init', { hash: artifact.hash });
     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');
+    const decodedBytecode = Buffer.from(artifact.bytecode, 'base64');
     //
     // Execute the circuit
     try {
-      const _witnessMap = await executeCircuit(
+      const result = await executeCircuit(
         decodedBytecode,
         input,
-        foreignCallHandler, // handle calls to debug_log
+        callback, // handle calls to debug_log
       );
-      this.log.debug('execution successful', { hash: compiledCircuit.hash });
-      return _witnessMap;
+      this.log.debug('execution successful', { hash: artifact.hash });
+      return result;
     } 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.
+      // 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(compiledCircuit, err as ExecutionError);
+        const parsed = enrichNoirError(artifact, err as ExecutionError);
         this.log.debug('execution failed', {
-          hash: compiledCircuit.hash,
+          hash: artifact.hash,
           error: parsed,
           message: parsed.message,
         });
         throw parsed;
       }
-      this.log.debug('execution failed', { hash: compiledCircuit.hash, error: err });
+      this.log.debug('execution failed', { hash: artifact.hash, error: err });
       throw new Error(`Circuit execution failed: ${err}`);
     }
   }
 
-  async executeUserCircuit(acir: Buffer, initialWitness: ACVMWitness, callback: ACIRCallback) {
+  async executeUserCircuit(
+    input: ACVMWitness,
+    artifact: FunctionArtifactWithContractName,
+    callback: ACIRCallback,
+  ): Promise<ACIRExecutionResult> {
     await this.init();
-    return acvm(acir, initialWitness, callback);
+    return acvm(artifact.bytecode, input, callback);
   }
 }

package/src/private/providers/acvm_wasm_with_blobs.ts

@@ -1,7 +1,7 @@
-import { type ExecutionError, executeCircuit } from '@aztec/noir-acvm_js';
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
+import { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import type { WitnessMap } from '@aztec/noir-types';
-import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
+import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
+import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
 
 import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
@@ -15,33 +15,36 @@ import { type SimulationProvider, enrichNoirError } from './simulation_provider.
  * It is only used in the context of server-side code executing simulated protocol circuits.
  */
 export class WASMSimulatorWithBlobs implements SimulationProvider {
-  async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
-    // Execute the circuit on those initial witness values
-    //
+  async executeProtocolCircuit(
+    input: WitnessMap,
+    artifact: NoirCompiledCircuitWithName,
+    callback: ForeignCallHandler,
+  ): Promise<WitnessMap> {
     // 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
     try {
       const _witnessMap = await executeCircuit(
         decodedBytecode,
         input,
-        foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
+        callback, // handle calls to debug_log and evaluate_blobs mock
       );
 
       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.
+      // 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) {
-        throw enrichNoirError(compiledCircuit, err as ExecutionError);
+        throw enrichNoirError(artifact, err as ExecutionError);
       }
       throw new Error(`Circuit execution failed: ${err}`);
     }
   }
 
   executeUserCircuit(
-    _acir: Buffer,
-    _initialWitness: ACVMWitness,
+    _input: ACVMWitness,
+    _artifact: FunctionArtifactWithContractName,
     _callback: ACIRCallback,
   ): Promise<ACIRExecutionResult> {
     throw new Error('Not implemented');