@aztec/simulator 0.41.0 → 0.42.0

package/src/avm/opcodes/arithmetic.ts

@@ -1,6 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getGasCostForTypeTag, getMemoryGasCost, sumGas } from '../avm_gas.js';
-import { type Field, type MemoryOperations, type MemoryValue, TypeTag } from '../avm_memory_types.js';
+import { type Field, type MemoryValue, TypeTag } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Instruction } from './instruction.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
@@ -23,12 +22,6 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     context.machineState.incrementPc();
   }
 
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
-    const baseGasCost = getGasCostForTypeTag(this.inTag, getBaseGasCost(this.opcode));
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
-
   protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
 }
 
@@ -101,10 +94,4 @@ export class FieldDiv extends Instruction {
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
-    const baseGasCost = getGasCostForTypeTag(TypeTag.FIELD, getBaseGasCost(this.opcode));
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }

package/src/avm/opcodes/conversion.ts

@@ -50,7 +50,7 @@ export class ToRadixLE extends Instruction {
       value /= radixBN;
     }
 
-    const res = [...limbArray].map(byte => new Uint8(byte));
+    const res = limbArray.map(byte => new Uint8(byte));
     memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);

package/src/avm/opcodes/external_calls.ts

@@ -86,13 +86,15 @@ abstract class ExternalCall extends Instruction {
     const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
 
     const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
-    const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
+    const simulator = new AvmSimulator(nestedContext);
+    const nestedCallResults: AvmContractCallResults = await simulator.execute();
     const pxResults = convertAvmResultsToPxResult(
       nestedCallResults,
       startSideEffectCounter,
       oldStyleExecution,
       Gas.from(allocatedGas),
       nestedContext,
+      simulator.getBytecode(),
     );
     // store the old PublicExecutionResult object to maintain a recursive data structure for the old kernel
     context.persistableState.transitionalExecutionResult.nestedExecutions.push(pxResults);

package/src/avm/opcodes/instruction.ts

@@ -1,7 +1,7 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
+import { getBaseGasCost, sumGas } from '../avm_gas.js';
 import { type MemoryOperations } from '../avm_memory_types.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -67,9 +67,11 @@ export abstract class Instruction {
    * @param memoryOps Memory operations performed by the instruction.
    * @returns Gas cost.
    */
-  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+  protected gasCost(_memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
     const baseGasCost = getBaseGasCost(this.opcode);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6861): reconsider.
+    // const memoryGasCost = getMemoryGasCost(memoryOps);
+    const memoryGasCost = { l2Gas: 0, daGas: 0 };
     return sumGas(baseGasCost, memoryGasCost);
   }
 

package/src/avm/opcodes/memory.ts

@@ -1,6 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
-import { Field, type MemoryOperations, TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -216,10 +215,4 @@ export class CalldataCopy extends Instruction {
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
-    const baseGasCost = getBaseGasCost(this.opcode);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }

package/src/avm/opcodes/storage.ts

@@ -1,8 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import type { AvmContext } from '../avm_context.js';
-import { type Gas, getBaseGasCost, getMemoryGasCost, mulGas, sumGas } from '../avm_gas.js';
-import { Field, type MemoryOperations } from '../avm_memory_types.js';
+import { Field } from '../avm_memory_types.js';
 import { StaticCallAlterationError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -26,12 +25,6 @@ abstract class BaseStorageInstruction extends Instruction {
   ) {
     super();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>): Gas {
-    const baseGasCost = mulGas(getBaseGasCost(this.opcode), this.size);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }
 
 export class SStore extends BaseStorageInstruction {

package/src/avm/serialization/bytecode_serialization.ts

@@ -136,7 +136,7 @@ const INSTRUCTION_SET = () =>
     // Misc
     [DebugLog.opcode, DebugLog],
 
-    // //// Gadgets
+    // Gadgets
     [Keccak.opcode, Keccak],
     [Poseidon2.opcode, Poseidon2],
     [Sha256.opcode, Sha256],

package/src/client/client_execution_context.ts

@@ -2,6 +2,7 @@ import {
   type AuthWitness,
   type AztecNode,
   EncryptedL2Log,
+  EncryptedL2NoteLog,
   L1NotePayload,
   Note,
   type NoteStatus,
@@ -10,9 +11,9 @@ import {
 } from '@aztec/circuit-types';
 import {
   CallContext,
-  FunctionData,
   FunctionSelector,
   type Header,
+  type KeyValidationRequest,
   PrivateContextInputs,
   PublicCallRequest,
   type TxContext,
@@ -21,6 +22,7 @@ import { Aes128 } from '@aztec/circuits.js/barretenberg';
 import { computePublicDataTreeLeafSlot, computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { type FunctionAbi, type FunctionArtifact, countArgumentsSize } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { pedersenHash } from '@aztec/foundation/crypto';
 import { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
 import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 
@@ -28,7 +30,7 @@ import { type NoteData, toACVMWitness } from '../acvm/index.js';
 import { type PackedValuesCache } from '../common/packed_values_cache.js';
 import { type DBOracle } from './db_oracle.js';
 import { type ExecutionNoteCache } from './execution_note_cache.js';
-import { CountedLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
+import { CountedLog, CountedNoteLog, type ExecutionResult, type NoteAndSlot } from './execution_result.js';
 import { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -56,7 +58,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
   private nullifiedNoteHashCounters: Map<number, number> = new Map();
-  private noteEncryptedLogs: CountedLog<EncryptedL2Log>[] = [];
+  private noteEncryptedLogs: CountedNoteLog[] = [];
   private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
@@ -136,33 +138,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.noteEncryptedLogs;
   }
 
-  /**
-   * Sometimes notes can be chopped after a nested execution is complete.
-   * This means finished nested executions still hold transient logs. This method removes them.
-   * TODO(Miranda): is there a cleaner solution?
-   */
-  public chopNoteEncryptedLogs() {
-    // Do not return logs that have been chopped in the cache
-    const allNoteLogs = this.noteCache.getLogs();
-    this.noteEncryptedLogs = this.noteEncryptedLogs.filter(l => allNoteLogs.includes(l));
-    const chop = (thing: any) =>
-      thing.nestedExecutions.forEach((result: ExecutionResult) => {
-        if (!result.noteEncryptedLogs[0]?.isEmpty()) {
-          // The execution has note logs
-          result.noteEncryptedLogs = result.noteEncryptedLogs.filter(l => allNoteLogs.includes(l));
-        }
-        chop(result);
-      });
-    chop(this);
-  }
-
-  /**
-   * Return the note encrypted logs emitted during this execution and nested executions.
-   */
-  public getAllNoteEncryptedLogs() {
-    return this.noteCache.getLogs();
-  }
-
   /**
    * Return the encrypted logs emitted during this execution.
    */
@@ -358,21 +333,31 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param encryptedNote - The encrypted data.
    * @param counter - The effects counter.
    */
-  public override emitEncryptedLog(encryptedData: Buffer, counter: number) {
-    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedData), counter);
+  public override emitEncryptedLog(
+    contractAddress: AztecAddress,
+    randomness: Fr,
+    encryptedData: Buffer,
+    counter: number,
+  ) {
+    // In some cases, we actually want to reveal the contract address we are siloing with:
+    // e.g. 'handshaking' contract w/ known address
+    // An app providing randomness = 0 signals to not mask the address.
+    const maskedContractAddress = randomness.isZero()
+      ? contractAddress.toField()
+      : pedersenHash([contractAddress, randomness], 0);
+    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedData, maskedContractAddress), counter);
     this.encryptedLogs.push(encryptedLog);
   }
 
   /**
    * Emit encrypted note data
-   * @param noteHash - The note hash.
+   * @param noteHashCounter - The note hash counter.
    * @param encryptedNote - The encrypted note data.
-   * @param counter - The effects counter.
+   * @param counter - The log counter.
    */
-  public override emitEncryptedNoteLog(noteHash: Fr, encryptedNote: Buffer, counter: number) {
-    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedNote), counter);
+  public override emitEncryptedNoteLog(noteHashCounter: number, encryptedNote: Buffer, counter: number) {
+    const encryptedLog = new CountedNoteLog(new EncryptedL2NoteLog(encryptedNote), counter, noteHashCounter);
     this.noteEncryptedLogs.push(encryptedLog);
-    this.noteCache.addNewLog(encryptedLog, noteHash);
   }
 
   /**
@@ -380,14 +365,16 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param contractAddress - The contract address of the note.
    * @param storageSlot - The storage slot the note is at.
    * @param noteTypeId - The type ID of the note.
-   * @param ivpk - The master incoming viewing public key.
+   * @param ovKeys - The outgoing viewing keys to use to encrypt.
+   * @param ivpkM - The master incoming viewing public key.
    * @param preimage - The note preimage.
    */
   public override computeEncryptedLog(
     contractAddress: AztecAddress,
     storageSlot: Fr,
     noteTypeId: Fr,
-    ivpk: Point,
+    ovKeys: KeyValidationRequest,
+    ivpkM: Point,
     preimage: Fr[],
   ) {
     const note = new Note(preimage);
@@ -396,11 +383,9 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     const ephSk = GrumpkinScalar.random();
 
-    // @todo Issue(#6410) Right now we are completely ignoring the outgoing log. Just drawing random data.
-    const ovsk = GrumpkinScalar.random();
     const recipient = AztecAddress.random();
 
-    return taggedNote.encrypt(ephSk, recipient, ivpk, ovsk);
+    return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
   }
 
   /**
@@ -468,7 +453,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     isStaticCall = isStaticCall || this.callContext.isStaticCall;
 
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
-    const targetFunctionData = FunctionData.fromAbi(targetArtifact);
 
     const derivedTxContext = this.txContext.clone();
 
@@ -498,7 +482,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       context,
       targetArtifact,
       targetContractAddress,
-      targetFunctionData,
+      functionSelector,
     );
 
     if (isStaticCall) {
@@ -552,7 +536,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       args,
       callContext: derivedCallContext,
       parentCallContext: this.callContext,
-      functionData: FunctionData.fromAbi(targetArtifact),
+      functionSelector,
       contractAddress: targetContractAddress,
     });
   }
@@ -684,4 +668,8 @@ export class ClientExecutionContext extends ViewDataOracle {
   public override debugLog(message: string, fields: Fr[]) {
     this.log.verbose(`debug_log ${applyStringFormatting(message, fields)}`);
   }
+
+  public getDebugFunctionName() {
+    return this.db.getDebugFunctionName(this.contractAddress, this.callContext.functionSelector);
+  }
 }

package/src/client/db_oracle.ts

@@ -12,7 +12,7 @@ import { type Fr } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type NoteData } from '../acvm/index.js';
-import { type CommitmentsDB } from '../public/db.js';
+import { type CommitmentsDB } from '../public/db_interfaces.js';
 
 /**
  * Error thrown when a contract is not found in the database.
@@ -95,6 +95,13 @@ export interface DBOracle extends CommitmentsDB {
    */
   getFunctionArtifact(contractAddress: AztecAddress, selector: FunctionSelector): Promise<FunctionArtifact>;
 
+  /**
+   * Generates a stable function name for debug purposes.
+   * @param contractAddress - The contract address.
+   * @param selector - The corresponding function selector.
+   */
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string>;
+
   /**
    * Retrieves the artifact of a specified function within a given contract.
    * The function is identified by its name, which is unique within a contract.

package/src/client/execution_note_cache.ts

@@ -1,10 +1,8 @@
-import { type EncryptedL2Log } from '@aztec/circuit-types';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
 import { type NoteData } from '../acvm/index.js';
-import { type CountedLog } from './execution_result.js';
 
 export interface PendingNote {
   note: NoteData;
@@ -29,13 +27,6 @@ export class ExecutionNoteCache {
    */
   private nullifiers: Map<bigint, Set<bigint>> = new Map();
 
-  /**
-   * The list of encrypted logs linked to note hashes created in this transaction.
-   * This mapping maps from inner note hash to log(s) emitted for that note hash.
-   * Note that their value (bigint representation) is used because Frs cannot be looked up in Sets.
-   */
-  private logs: Map<bigint, CountedLog<EncryptedL2Log>[]> = new Map();
-
   /**
    * Add a new note to cache.
    * @param note - New note created during execution.
@@ -46,16 +37,6 @@ export class ExecutionNoteCache {
     this.newNotes.set(note.contractAddress.toBigInt(), notes);
   }
 
-  /**
-   * Add a new note to cache.
-   * @param note - New note created during execution.
-   */
-  public addNewLog(log: CountedLog<EncryptedL2Log>, innerNoteHash: Fr) {
-    const logs = this.logs.get(innerNoteHash.toBigInt()) ?? [];
-    logs.push(log);
-    this.logs.set(innerNoteHash.toBigInt(), logs);
-  }
-
   /**
    * Add a nullifier to cache. It could be for a db note or a new note created during execution.
    * @param contractAddress - Contract address of the note.
@@ -81,8 +62,6 @@ export class ExecutionNoteCache {
       const note = notes.splice(noteIndexToRemove, 1)[0];
       nullifiedNoteHashCounter = note.counter;
       this.newNotes.set(contractAddress.toBigInt(), notes);
-      // If a log linked to the note hash does not exist, this method just does nothing
-      this.logs.delete(innerNoteHash.toBigInt());
     }
 
     return nullifiedNoteHashCounter;
@@ -117,11 +96,4 @@ export class ExecutionNoteCache {
   public getNullifiers(contractAddress: AztecAddress): Set<bigint> {
     return this.nullifiers.get(contractAddress.toBigInt()) ?? new Set();
   }
-
-  /**
-   * Return all note logs emitted from a contract.
-   */
-  public getLogs(): CountedLog<EncryptedL2Log>[] {
-    return Array.from(this.logs.values()).flat();
-  }
 }

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) {
@@ -193,10 +170,13 @@ export class AcirSimulator {
     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]),
+      returnTypes: artifact.returnTypes,
     };
 
     const [innerNoteHash, uniqueNoteHash, siloedNoteHash, innerNullifier] = (await this.runUnconstrained(