@aztec/simulator 0.40.1 → 0.42.0

package/src/client/client_execution_context.ts

@@ -1,20 +1,19 @@
 import {
   type AuthWitness,
   type AztecNode,
-  EncryptedFunctionL2Logs,
   EncryptedL2Log,
+  EncryptedL2NoteLog,
   L1NotePayload,
   Note,
   type NoteStatus,
   TaggedNote,
-  UnencryptedFunctionL2Logs,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
   CallContext,
-  FunctionData,
   FunctionSelector,
   type Header,
+  type KeyValidationRequest,
   PrivateContextInputs,
   PublicCallRequest,
   type TxContext,
@@ -22,16 +21,16 @@ import {
 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 { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr, type Point } from '@aztec/foundation/fields';
+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';
 
 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 { type LogsCache } from './logs_cache.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';
@@ -59,6 +58,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   private noteHashLeafIndexMap: Map<bigint, bigint> = new Map();
   private nullifiedNoteHashCounters: Map<number, number> = new Map();
+  private noteEncryptedLogs: CountedNoteLog[] = [];
   private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
@@ -76,7 +76,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     authWitnesses: AuthWitness[],
     private readonly packedValuesCache: PackedValuesCache,
     private readonly noteCache: ExecutionNoteCache,
-    private readonly logsCache: LogsCache,
     db: DBOracle,
     private node: AztecNode,
     protected sideEffectCounter: number = 0,
@@ -133,17 +132,17 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * Return the encrypted logs emitted during this execution.
+   * Return the note encrypted logs emitted during this execution.
    */
-  public getEncryptedLogs() {
-    return this.encryptedLogs;
+  public getNoteEncryptedLogs() {
+    return this.noteEncryptedLogs;
   }
 
   /**
-   * Return the encrypted logs emitted during this execution and nested executions.
+   * Return the encrypted logs emitted during this execution.
    */
-  public getAllEncryptedLogs() {
-    return new EncryptedFunctionL2Logs(this.logsCache.getEncryptedLogs());
+  public getEncryptedLogs() {
+    return this.encryptedLogs;
   }
 
   /**
@@ -153,13 +152,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.unencryptedLogs;
   }
 
-  /**
-   * Return the unencrypted logs emitted during this execution and nested executions.
-   */
-  public getAllUnencryptedLogs() {
-    return new UnencryptedFunctionL2Logs(this.logsCache.getUnencryptedLogs());
-  }
-
   /**
    * Return the nested execution results during this execution.
    */
@@ -337,29 +329,63 @@ export class ClientExecutionContext extends ViewDataOracle {
   }
 
   /**
-   * Encrypt a note and emit it as a log.
+   * Emit encrypted data
+   * @param encryptedNote - The encrypted data.
+   * @param counter - The effects 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 noteHashCounter - The note hash counter.
+   * @param encryptedNote - The encrypted note data.
+   * @param counter - The log counter.
+   */
+  public override emitEncryptedNoteLog(noteHashCounter: number, encryptedNote: Buffer, counter: number) {
+    const encryptedLog = new CountedNoteLog(new EncryptedL2NoteLog(encryptedNote), counter, noteHashCounter);
+    this.noteEncryptedLogs.push(encryptedLog);
+  }
+
+  /**
+   * Encrypt a note
    * @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 publicKey - The public key of the account that can decrypt the log.
-   * @param log - The log contents.
+   * @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 emitEncryptedLog(
+  public override computeEncryptedLog(
     contractAddress: AztecAddress,
     storageSlot: Fr,
     noteTypeId: Fr,
-    publicKey: Point,
-    log: Fr[],
-    counter: number,
+    ovKeys: KeyValidationRequest,
+    ivpkM: Point,
+    preimage: Fr[],
   ) {
-    const note = new Note(log);
+    const note = new Note(preimage);
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
     const taggedNote = new TaggedNote(l1NotePayload);
-    const encryptedNote = taggedNote.toEncryptedBuffer(publicKey);
-    const encryptedLog = new EncryptedL2Log(encryptedNote);
-    this.encryptedLogs.push(new CountedLog(encryptedLog, counter));
-    this.logsCache.addEncryptedLog(encryptedLog);
-    return encryptedNote;
+
+    const ephSk = GrumpkinScalar.random();
+
+    const recipient = AztecAddress.random();
+
+    return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
   }
 
   /**
@@ -368,7 +394,6 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   public override emitUnencryptedLog(log: UnencryptedL2Log, counter: number) {
     this.unencryptedLogs.push(new CountedLog(log, counter));
-    this.logsCache.addUnencryptedLog(log);
     const text = log.toHumanReadable();
     this.log.verbose(`Emitted unencrypted log: "${text.length > 100 ? text.slice(0, 100) + '...' : text}"`);
   }
@@ -382,7 +407,6 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   public override emitContractClassUnencryptedLog(log: UnencryptedL2Log, counter: number) {
     this.unencryptedLogs.push(new CountedLog(log, counter));
-    this.logsCache.addUnencryptedLog(log);
     const text = log.toHumanReadable();
     this.log.verbose(
       `Emitted unencrypted log from ContractClassRegisterer: "${
@@ -397,10 +421,10 @@ export class ClientExecutionContext extends ViewDataOracle {
       childExecutionResult.callStackItem.publicInputs.newNoteHashes.some(item => !item.isEmpty()) ||
       childExecutionResult.callStackItem.publicInputs.newNullifiers.some(item => !item.isEmpty()) ||
       childExecutionResult.callStackItem.publicInputs.newL2ToL1Msgs.some(item => !item.isEmpty()) ||
-      !childExecutionResult.callStackItem.publicInputs.encryptedLogPreimagesLength.equals(new Fr(4)) ||
-      !childExecutionResult.callStackItem.publicInputs.unencryptedLogPreimagesLength.equals(new Fr(4))
+      childExecutionResult.callStackItem.publicInputs.encryptedLogsHashes.some(item => !item.isEmpty()) ||
+      childExecutionResult.callStackItem.publicInputs.unencryptedLogsHashes.some(item => !item.isEmpty())
     ) {
-      throw new Error(`Static call cannot create new notes, emit L2->L1 messages or generate logs`);
+      throw new Error(`Static call cannot update the state, emit L2->L1 messages or generate logs`);
     }
   }
 
@@ -411,7 +435,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param argsHash - The packed arguments 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.
-   * @param isStaticCall - Whether the call is a delegate call.
+   * @param isDelegateCall - Whether the call is a delegate call.
    * @returns The execution result.
    */
   override async callPrivateFunction(
@@ -429,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();
 
@@ -450,7 +473,6 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.authWitnesses,
       this.packedValuesCache,
       this.noteCache,
-      this.logsCache,
       this.db,
       this.node,
       sideEffectCounter,
@@ -460,7 +482,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       context,
       targetArtifact,
       targetContractAddress,
-      targetFunctionData,
+      functionSelector,
     );
 
     if (isStaticCall) {
@@ -514,7 +536,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       args,
       callContext: derivedCallContext,
       parentCallContext: this.callContext,
-      functionData: FunctionData.fromAbi(targetArtifact),
+      functionSelector,
       contractAddress: targetContractAddress,
     });
   }
@@ -646,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

@@ -5,14 +5,14 @@ import {
   type NullifierMembershipWitness,
   type PublicDataWitness,
 } from '@aztec/circuit-types';
-import { type CompleteAddress, type Header } from '@aztec/circuits.js';
+import { type CompleteAddress, type Header, type KeyValidationRequest } from '@aztec/circuits.js';
 import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { type ContractInstance } from '@aztec/types/contracts';
 
-import { type NoteData, type NullifierKeys } from '../acvm/index.js';
-import { type CommitmentsDB } from '../public/db.js';
+import { type NoteData } from '../acvm/index.js';
+import { type CommitmentsDB } from '../public/db_interfaces.js';
 
 /**
  * Error thrown when a contract is not found in the database.
@@ -45,10 +45,11 @@ export interface DBOracle extends CommitmentsDB {
 
   /**
    * Retrieve the complete address associated to a given address.
-   * @param address - Address to fetch the pubkey for.
+   * @param account - The account address.
    * @returns A complete address associated with the input address.
+   * @throws An error if the account is not registered in the database.
    */
-  getCompleteAddress(address: AztecAddress): Promise<CompleteAddress>;
+  getCompleteAddress(account: AztecAddress): Promise<CompleteAddress>;
 
   /**
    * Retrieve the auth witness for a given message hash.
@@ -65,14 +66,12 @@ export interface DBOracle extends CommitmentsDB {
   popCapsule(): Promise<Fr[]>;
 
   /**
-   * Retrieve nullifier keys associated with a specific account and app/contract address.
-   *
-   * @param accountAddress - The account address.
-   * @param contractAddress - The contract address.
-   * @returns A Promise that resolves to nullifier keys of a requested account and contract.
-   * @throws An error if the account is not registered in the database.
+   * Retrieve keys associated with a specific master public key and app address.
+   * @param pkMHash - The master public key hash.
+   * @returns A Promise that resolves to nullifier keys.
+   * @throws If the keys are not registered in the key store.
    */
-  getNullifierKeys(accountAddress: AztecAddress, contractAddress: AztecAddress): Promise<NullifierKeys>;
+  getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest>;
 
   /**
    * Retrieves a set of notes stored in the database for a given contract address and storage slot.
@@ -96,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

@@ -52,7 +52,7 @@ export class ExecutionNoteCache {
     this.nullifiers.set(contractAddress.toBigInt(), nullifiers);
 
     let nullifiedNoteHashCounter: number | undefined = undefined;
-    // Find and remove the matching new note if the emitted innerNoteHash is not empty.
+    // Find and remove the matching new note and log(s) if the emitted innerNoteHash is not empty.
     if (!innerNoteHash.equals(Fr.ZERO)) {
       const notes = this.newNotes.get(contractAddress.toBigInt()) ?? [];
       const noteIndexToRemove = notes.findIndex(n => n.note.innerNoteHash.equals(innerNoteHash));

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.
  */
@@ -58,6 +65,11 @@ export interface ExecutionResult {
   enqueuedPublicFunctionCalls: PublicCallRequest[];
   /** Public function execution requested for teardown */
   publicTeardownFunctionCall: PublicCallRequest;
+  /**
+   * Encrypted note logs emitted during execution of this function call.
+   * Note: These are preimages to `noteEncryptedLogsHashes`.
+   */
+  noteEncryptedLogs: CountedNoteLog[];
   /**
    * Encrypted logs emitted during execution of this function call.
    * Note: These are preimages to `encryptedLogsHashes`.
@@ -82,13 +94,39 @@ export function collectNullifiedNoteHashCounters(execResult: ExecutionResult, ac
   return accum;
 }
 
+/**
+ * Collect all encrypted logs across all nested executions.
+ * @param execResult - The topmost execution result.
+ * @returns All encrypted logs.
+ */
+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();
+}
+
+/**
+ * Collect all encrypted logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All encrypted logs.
+ */
+export function collectSortedNoteEncryptedLogs(execResult: ExecutionResult): EncryptedNoteFunctionL2Logs {
+  const nullifiedNoteHashCounters = collectNullifiedNoteHashCounters(execResult);
+  const allLogs = collectNoteEncryptedLogs(execResult, nullifiedNoteHashCounters);
+  const sortedLogs = sortByCounter(allLogs);
+  return new EncryptedNoteFunctionL2Logs(sortedLogs.map(l => l.log));
+}
 /**
  * Collect all encrypted logs across all nested executions.
  * @param execResult - The topmost execution result.
  * @returns All encrypted logs.
  */
 function collectEncryptedLogs(execResult: ExecutionResult): CountedLog<EncryptedL2Log>[] {
-  return [execResult.encryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectEncryptedLogs)].flat();
+  return [execResult.encryptedLogs, ...execResult.nestedExecutions.flatMap(collectEncryptedLogs)].flat();
 }
 
 /**
@@ -108,7 +146,7 @@ export function collectSortedEncryptedLogs(execResult: ExecutionResult): Encrypt
  * @returns All unencrypted logs.
  */
 function collectUnencryptedLogs(execResult: ExecutionResult): CountedLog<UnencryptedL2Log>[] {
-  return [execResult.unencryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectUnencryptedLogs)].flat();
+  return [execResult.unencryptedLogs, ...execResult.nestedExecutions.flatMap(collectUnencryptedLogs)].flat();
 }
 
 /**

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,35 +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);
 
+  // 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);
 
@@ -69,6 +86,7 @@ export async function executePrivateFunction(
     vk: Buffer.from(artifact.verificationKey!, 'hex'),
     nestedExecutions,
     enqueuedPublicFunctionCalls,
+    noteEncryptedLogs,
     publicTeardownFunctionCall,
     encryptedLogs,
     unencryptedLogs,

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,15 +11,12 @@ 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';
 import { type DBOracle } from './db_oracle.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { type ExecutionResult } from './execution_result.js';
-import { LogsCache } from './logs_cache.js';
 import { executePrivateFunction } from './private_execution.js';
 import { executeUnconstrainedFunction } from './unconstrained_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -28,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.
@@ -69,8 +45,8 @@ export class AcirSimulator {
     contractAddress: AztecAddress,
     msgSender = AztecAddress.ZERO,
   ): Promise<ExecutionResult> {
-    if (entryPointArtifact.functionType !== FunctionType.SECRET) {
-      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as secret`);
+    if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
+      throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
     }
 
     if (request.origin !== contractAddress) {
@@ -89,7 +65,7 @@ export class AcirSimulator {
       contractAddress,
       FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
       false,
-      false,
+      entryPointArtifact.isStatic,
       startSideEffectCounter,
     );
     const context = new ClientExecutionContext(
@@ -101,7 +77,6 @@ export class AcirSimulator {
       request.authWitnesses,
       PackedValuesCache.create(request.argsOfCalls),
       new ExecutionNoteCache(),
-      new LogsCache(),
       this.db,
       this.node,
       startSideEffectCounter,
@@ -112,7 +87,7 @@ export class AcirSimulator {
         context,
         entryPointArtifact,
         contractAddress,
-        request.functionData,
+        request.functionSelector,
       );
       return executionResult;
     } catch (err) {
@@ -143,7 +118,7 @@ export class AcirSimulator {
         context,
         entryPointArtifact,
         contractAddress,
-        request.functionData,
+        request.selector,
         request.args,
       );
     } catch (err) {
@@ -195,9 +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(