@aztec/simulator 0.56.0 → 0.57.0

package/src/client/client_execution_context.ts

@@ -1,50 +1,37 @@
 import {
   type AuthWitness,
   type AztecNode,
+  CountedLog,
+  CountedNoteLog,
+  CountedPublicExecutionRequest,
   EncryptedL2Log,
   EncryptedL2NoteLog,
-  Event,
-  L1EventPayload,
-  L1NotePayload,
   Note,
+  NoteAndSlot,
   type NoteStatus,
+  type PrivateExecutionResult,
   PublicExecutionRequest,
-  TaggedLog,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
   CallContext,
   FunctionSelector,
   type Header,
-  type KeyValidationRequest,
+  PUBLIC_DISPATCH_SELECTOR,
   PrivateContextInputs,
   type TxContext,
 } from '@aztec/circuits.js';
-import { Aes128 } from '@aztec/circuits.js/barretenberg';
 import { computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
-import {
-  EventSelector,
-  type FunctionAbi,
-  type FunctionArtifact,
-  type NoteSelector,
-  countArgumentsSize,
-} from '@aztec/foundation/abi';
+import { type FunctionAbi, type FunctionArtifact, type NoteSelector, countArgumentsSize } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
+import { Fr } 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,
-  CountedNoteLog,
-  CountedPublicExecutionRequest,
-  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';
@@ -75,7 +62,7 @@ export class ClientExecutionContext extends ViewDataOracle {
   private noteEncryptedLogs: CountedNoteLog[] = [];
   private encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
-  private nestedExecutions: ExecutionResult[] = [];
+  private nestedExecutions: PrivateExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: CountedPublicExecutionRequest[] = [];
   private publicTeardownFunctionCall: PublicExecutionRequest = PublicExecutionRequest.empty();
 
@@ -314,11 +301,7 @@ export class ClientExecutionContext extends ViewDataOracle {
       },
       counter,
     );
-    this.newNotes.push({
-      storageSlot,
-      noteTypeId,
-      note,
-    });
+    this.newNotes.push(new NoteAndSlot(note, storageSlot, noteTypeId));
   }
 
   /**
@@ -373,62 +356,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     this.noteEncryptedLogs.push(encryptedLog);
   }
 
-  /**
-   * Encrypt an event
-   * @param contractAddress - The contract emitting the encrypted event.
-   * @param randomness - A value used to mask the contract address we are siloing with.
-   * @param eventTypeId - The type ID of the event (function selector).
-   * @param ovKeys - The outgoing viewing keys to use to encrypt.
-   * @param ivpkM - The master incoming viewing public key.
-   * @param recipient - The recipient of the encrypted event log.
-   * @param preimage - The event preimage.
-   */
-  public override computeEncryptedEventLog(
-    contractAddress: AztecAddress,
-    randomness: Fr,
-    eventTypeId: Fr,
-    ovKeys: KeyValidationRequest,
-    ivpkM: Point,
-    recipient: AztecAddress,
-    preimage: Fr[],
-  ) {
-    const event = new Event(preimage);
-    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, EventSelector.fromField(eventTypeId));
-    const taggedEvent = new TaggedLog(l1EventPayload);
-
-    const ephSk = GrumpkinScalar.random();
-
-    return taggedEvent.encrypt(ephSk, recipient, ivpkM, ovKeys);
-  }
-
-  /**
-   * 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 ovKeys - The outgoing viewing keys to use to encrypt.
-   * @param ivpkM - The master incoming viewing public key.
-   * @param recipient - The recipient of the encrypted note log.
-   * @param preimage - The note preimage.
-   */
-  public override computeEncryptedNoteLog(
-    contractAddress: AztecAddress,
-    storageSlot: Fr,
-    noteTypeId: NoteSelector,
-    ovKeys: KeyValidationRequest,
-    ivpkM: Point,
-    recipient: AztecAddress,
-    preimage: Fr[],
-  ) {
-    const note = new Note(preimage);
-    const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
-    const taggedNote = new TaggedLog(l1NotePayload);
-
-    const ephSk = GrumpkinScalar.random();
-
-    return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
-  }
-
   /**
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
@@ -457,7 +384,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     return Fr.fromBuffer(log.hash());
   }
 
-  #checkValidStaticCall(childExecutionResult: ExecutionResult) {
+  #checkValidStaticCall(childExecutionResult: PrivateExecutionResult) {
     if (
       childExecutionResult.callStackItem.publicInputs.noteHashes.some(item => !item.isEmpty()) ||
       childExecutionResult.callStackItem.publicInputs.nullifiers.some(item => !item.isEmpty()) ||
@@ -568,7 +495,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const args = this.packedValuesCache.unpack(argsHash);
 
     this.log.verbose(
-      `Created PublicExecutionRequest of type [${callType}], side-effect counter [${sideEffectCounter}] to ${targetContractAddress}:${functionSelector}(${targetArtifact.name})`,
+      `Created PublicExecutionRequest to ${targetArtifact.name}@${targetContractAddress}, of type [${callType}], side-effect counter [${sideEffectCounter}]`,
     );
 
     const request = PublicExecutionRequest.from({
@@ -602,16 +529,27 @@ export class ClientExecutionContext extends ViewDataOracle {
     sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ) {
+  ): Promise<Fr> {
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
+    // WARNING: This is insecure and should be temporary!
+    // The oracle repacks 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 = this.packedValuesCache.pack([
+      functionSelector.toField(),
+      ...this.packedValuesCache.unpack(argsHash),
+    ]);
     await this.createPublicExecutionRequest(
       'enqueued',
       targetContractAddress,
-      functionSelector,
-      argsHash,
+      FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+      newArgsHash,
       sideEffectCounter,
       isStaticCall,
       isDelegateCall,
     );
+    return newArgsHash;
   }
 
   /**
@@ -632,16 +570,27 @@ export class ClientExecutionContext extends ViewDataOracle {
     sideEffectCounter: number,
     isStaticCall: boolean,
     isDelegateCall: boolean,
-  ) {
+  ): Promise<Fr> {
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.
+    // WARNING: This is insecure and should be temporary!
+    // The oracle repacks 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 = this.packedValuesCache.pack([
+      functionSelector.toField(),
+      ...this.packedValuesCache.unpack(argsHash),
+    ]);
     await this.createPublicExecutionRequest(
       'teardown',
       targetContractAddress,
-      functionSelector,
-      argsHash,
+      FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+      newArgsHash,
       sideEffectCounter,
       isStaticCall,
       isDelegateCall,
     );
+    return newArgsHash;
   }
 
   public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): void {
@@ -698,11 +647,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     return values;
   }
 
-  public override aes128Encrypt(input: Buffer, initializationVector: Buffer, key: Buffer): Buffer {
-    const aes128 = new Aes128();
-    return aes128.encryptBufferCBC(input, initializationVector, key);
-  }
-
   public override debugLog(message: string, fields: Fr[]) {
     this.log.verbose(`debug_log ${applyStringFormatting(message, fields)}`);
   }

package/src/client/index.ts

@@ -1,5 +1,4 @@
 export * from './simulator.js';
 export * from './db_oracle.js';
-export * from './execution_result.js';
 export * from './pick_notes.js';
 export * from './execution_note_cache.js';

package/src/client/private_execution.ts

@@ -1,3 +1,4 @@
+import { PrivateExecutionResult } from '@aztec/circuit-types';
 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';
@@ -9,7 +10,6 @@ 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';
 
 /**
  * Execute a private function and return the execution result.
@@ -19,10 +19,10 @@ export async function executePrivateFunction(
   artifact: FunctionArtifact,
   contractAddress: AztecAddress,
   functionSelector: FunctionSelector,
-  log = createDebugLogger('aztec:simulator:secret_execution'),
-): Promise<ExecutionResult> {
+  log = createDebugLogger('aztec:simulator:private_execution'),
+): Promise<PrivateExecutionResult> {
   const functionName = await context.getDebugFunctionName();
-  log.verbose(`Executing external function ${contractAddress}:${functionSelector}(${functionName})`);
+  log.verbose(`Executing external function ${functionName}@${contractAddress}`);
   const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);
@@ -75,20 +75,20 @@ export async function executePrivateFunction(
 
   log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
-  return {
+  return new PrivateExecutionResult(
     acir,
+    Buffer.from(artifact.verificationKey!, 'hex'),
     partialWitness,
     callStackItem,
-    returnValues: rawReturnValues,
     noteHashLeafIndexMap,
     newNotes,
     noteHashNullifierCounterMap,
-    vk: Buffer.from(artifact.verificationKey!, 'hex'),
+    rawReturnValues,
     nestedExecutions,
     enqueuedPublicFunctionCalls,
-    noteEncryptedLogs,
     publicTeardownFunctionCall,
+    noteEncryptedLogs,
     encryptedLogs,
     unencryptedLogs,
-  };
+  );
 }

package/src/client/simulator.ts

@@ -1,4 +1,4 @@
-import { type AztecNode, type FunctionCall, type Note, type TxExecutionRequest } from '@aztec/circuit-types';
+import type { AztecNode, FunctionCall, Note, PrivateExecutionResult, TxExecutionRequest } from '@aztec/circuit-types';
 import { CallContext } from '@aztec/circuits.js';
 import {
   type ArrayType,
@@ -17,7 +17,6 @@ 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 { executePrivateFunction } from './private_execution.js';
 import { executeUnconstrainedFunction } from './unconstrained_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -47,7 +46,7 @@ export class AcirSimulator {
     contractAddress: AztecAddress,
     msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE),
     scopes?: AztecAddress[],
-  ): Promise<ExecutionResult> {
+  ): Promise<PrivateExecutionResult> {
     if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
     }

package/src/common/debug_fn_name.ts

@@ -0,0 +1,22 @@
+import { type AztecAddress, Fr, FunctionSelector, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
+
+import { type WorldStateDB } from '../public/public_db_sources.js';
+
+export async function getPublicFunctionDebugName(
+  db: WorldStateDB,
+  contractAddress: AztecAddress,
+  fn: FunctionSelector,
+  calldata: Fr[],
+): Promise<string> {
+  if (fn.equals(FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)))) {
+    // If the function is a dispatch, we need to look up the target function which
+    // is expected to be the first argument.
+    const targetFunction =
+      calldata[0] !== undefined
+        ? await db.getDebugFunctionName(contractAddress, FunctionSelector.fromField(calldata[0]))
+        : `<calldata[0] undefined>`;
+    return `${targetFunction} (via dispatch)`;
+  } else {
+    return (await db.getDebugFunctionName(contractAddress, fn)) ?? `${contractAddress}:${fn}`;
+  }
+}

package/src/common/index.ts

@@ -1,4 +1,3 @@
 export * from './packed_values_cache.js';
 export * from './errors.js';
 export * from './side_effect_counter.js';
-export * from './return_values.js';

package/src/public/enqueued_call_simulator.ts

@@ -63,8 +63,7 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { accumulateReturnValues } from '../common/index.js';
-import { type PublicExecutionResult, collectExecutionResults } from './execution.js';
+import { type PublicExecutionResult, accumulatePublicReturnValues, collectExecutionResults } from './execution.js';
 import { type PublicExecutor } from './executor.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
@@ -226,7 +225,7 @@ export class EnqueuedCallSimulator {
       provingRequests,
       kernelOutput,
       newUnencryptedLogs: topResult.allUnencryptedLogs,
-      returnValues: accumulateReturnValues(topResult),
+      returnValues: accumulatePublicReturnValues(topResult),
       gasUsed,
       revertReason,
     };

package/src/public/execution.ts

@@ -1,4 +1,5 @@
 import {
+  NestedProcessReturnValues,
   type PublicExecutionRequest,
   type SimulationError,
   type UnencryptedFunctionL2Logs,
@@ -86,8 +87,6 @@ export interface PublicExecutionResult {
    */
   allUnencryptedLogs: UnencryptedFunctionL2Logs;
 
-  // TODO(dbanks12): add contract instance read requests
-
   /** The requests to call public functions made by this call. */
   publicCallRequests: PublicInnerCallRequest[];
   /** The results of nested calls. */
@@ -100,6 +99,18 @@ export interface PublicExecutionResult {
   functionName: string;
 }
 
+/**
+ * Recursively accummulate the return values of a call result and its nested executions,
+ * so they can be retrieved in order.
+ * @param executionResult
+ * @returns
+ */
+export function accumulatePublicReturnValues(executionResult: PublicExecutionResult): NestedProcessReturnValues {
+  const acc = new NestedProcessReturnValues(executionResult.returnValues);
+  acc.nested = executionResult.nestedExecutions.map(nestedExecution => accumulatePublicReturnValues(nestedExecution));
+  return acc;
+}
+
 export function collectExecutionResults(result: PublicExecutionResult): PublicExecutionResult[] {
   return [result, ...result.nestedExecutions.map(collectExecutionResults)].flat();
 }

package/src/public/executor.ts

@@ -1,6 +1,6 @@
 import { type PublicExecutionRequest } from '@aztec/circuit-types';
 import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
-import { Fr, Gas, type GlobalVariables, type Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
+import { Fr, Gas, type GlobalVariables, type Nullifier, type TxContext } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { type TelemetryClient } from '@aztec/telemetry-client';
@@ -10,6 +10,7 @@ import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
 import { AvmSimulator } from '../avm/avm_simulator.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
+import { getPublicFunctionDebugName } from '../common/debug_fn_name.js';
 import { type PublicExecutionResult } from './execution.js';
 import { ExecutorMetrics } from './executor_metrics.js';
 import { type WorldStateDB } from './public_db_sources.js';
@@ -21,7 +22,7 @@ import { PublicSideEffectTrace } from './side_effect_trace.js';
 export class PublicExecutor {
   metrics: ExecutorMetrics;
 
-  constructor(private readonly worldStateDB: WorldStateDB, private readonly header: Header, client: TelemetryClient) {
+  constructor(private readonly worldStateDB: WorldStateDB, client: TelemetryClient) {
     this.metrics = new ExecutorMetrics(client, 'PublicExecutor');
   }
 
@@ -49,9 +50,9 @@ export class PublicExecutor {
   ): Promise<PublicExecutionResult> {
     const address = executionRequest.contractAddress;
     const selector = executionRequest.callContext.functionSelector;
-    const fnName = (await this.worldStateDB.getDebugFunctionName(address, selector)) ?? `${address}:${selector}`;
+    const fnName = await getPublicFunctionDebugName(this.worldStateDB, address, selector, executionRequest.args);
 
-    PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}.`);
+    PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}@${address}.`);
     const timer = new Timer();
 
     const trace = new PublicSideEffectTrace(startSideEffectCounter);
@@ -61,12 +62,7 @@ export class PublicExecutor {
       pendingSiloedNullifiers.map(n => n.value),
     );
 
-    const avmExecutionEnv = createAvmExecutionEnvironment(
-      executionRequest,
-      this.header,
-      globalVariables,
-      transactionFee,
-    );
+    const avmExecutionEnv = createAvmExecutionEnvironment(executionRequest, globalVariables, transactionFee);
 
     const avmMachineState = new AvmMachineState(availableGas);
     const avmContext = new AvmContext(avmPersistableState, avmExecutionEnv, avmMachineState);
@@ -120,7 +116,6 @@ export class PublicExecutor {
  */
 function createAvmExecutionEnvironment(
   executionRequest: PublicExecutionRequest,
-  header: Header,
   globalVariables: GlobalVariables,
   transactionFee: Fr,
 ): AvmExecutionEnvironment {
@@ -131,7 +126,6 @@ function createAvmExecutionEnvironment(
     executionRequest.callContext.functionSelector,
     /*contractCallDepth=*/ Fr.zero(),
     transactionFee,
-    header,
     globalVariables,
     executionRequest.callContext.isStaticCall,
     executionRequest.callContext.isDelegateCall,

package/src/public/hints_builder.ts

@@ -49,15 +49,13 @@ export class HintsBuilder {
     nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
   ) {
-    return (
-      await buildSiloedNullifierReadRequestHints(
-        this,
-        nullifierReadRequests,
-        pendingNullifiers,
-        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-      )
-    ).hints;
+    return await buildSiloedNullifierReadRequestHints(
+      this,
+      nullifierReadRequests,
+      pendingNullifiers,
+      MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+      MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+    );
   }
 
   getNullifierNonExistentReadRequestHints(

package/src/public/public_processor.ts

@@ -57,7 +57,7 @@ export class PublicProcessorFactory {
     const historicalHeader = maybeHistoricalHeader ?? merkleTree.getInitialHeader();
 
     const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
-    const publicExecutor = new PublicExecutor(worldStateDB, historicalHeader, telemetryClient);
+    const publicExecutor = new PublicExecutor(worldStateDB, telemetryClient);
     const publicKernelSimulator = new RealPublicKernelCircuitSimulator(this.simulator);
 
     return PublicProcessor.create(
@@ -70,6 +70,10 @@ export class PublicProcessorFactory {
       this.telemetryClient,
     );
   }
+
+  public getInitialHeader() {
+    return this.merkleTree.getInitialHeader();
+  }
 }
 
 /**

package/src/public/side_effect_errors.ts

@@ -0,0 +1,6 @@
+export class SideEffectLimitReachedError extends Error {
+  constructor(sideEffectType: string, limit: number) {
+    super(`Reached the limit on number of '${sideEffectType}' side effects: ${limit}`);
+    this.name = 'SideEffectLimitReachedError';
+  }
+}