@aztec/simulator 0.37.0 → 0.39.0

package/src/client/execution_result.ts

@@ -1,9 +1,11 @@
-import { type EncryptedFunctionL2Logs, type Note, type UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
-  type NoteHashReadRequestMembershipWitness,
-  type PrivateCallStackItem,
-  type PublicCallRequest,
-} from '@aztec/circuits.js';
+  EncryptedFunctionL2Logs,
+  type EncryptedL2Log,
+  type Note,
+  UnencryptedFunctionL2Logs,
+  type UnencryptedL2Log,
+} from '@aztec/circuit-types';
+import { type IsEmpty, type PrivateCallStackItem, PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm/index.js';
@@ -20,9 +22,12 @@ export interface NoteAndSlot {
   noteTypeId: Fr;
 }
 
-export interface NullifiedNoteHashCounter {
-  noteHashCounter: number;
-  nullifierCounter: number;
+export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2Log> implements IsEmpty {
+  constructor(public log: TLog, public counter: number) {}
+
+  isEmpty(): boolean {
+    return !this.log.data.length && !this.counter;
+  }
 }
 
 /**
@@ -39,34 +44,42 @@ export interface ExecutionResult {
   // Needed for the verifier (kernel)
   /** The call stack item. */
   callStackItem: PrivateCallStackItem;
-  /** The partially filled-in read request membership witnesses for commitments being read. */
-  noteHashReadRequestPartialWitnesses: NoteHashReadRequestMembershipWitness[];
+  /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */
+  noteHashLeafIndexMap: Map<bigint, bigint>;
   /** The notes created in the executed function. */
   newNotes: NoteAndSlot[];
-  nullifiedNoteHashCounters: NullifiedNoteHashCounter[];
+  /** Mapping of note hash counter to the counter of its nullifier. */
+  nullifiedNoteHashCounters: Map<number, number>;
   /** The raw return values of the executed function. */
   returnValues: Fr[];
   /** The nested executions. */
   nestedExecutions: this[];
   /** Enqueued public function execution requests to be picked up by the sequencer. */
   enqueuedPublicFunctionCalls: PublicCallRequest[];
+  /** Public function execution requested for teardown */
+  publicTeardownFunctionCall: PublicCallRequest;
   /**
    * Encrypted logs emitted during execution of this function call.
    * Note: These are preimages to `encryptedLogsHashes`.
    */
-  encryptedLogs: EncryptedFunctionL2Logs;
+  encryptedLogs: CountedLog<EncryptedL2Log>[];
   /**
    * Unencrypted logs emitted during execution of this function call.
    * Note: These are preimages to `unencryptedLogsHashes`.
    */
-  unencryptedLogs: UnencryptedFunctionL2Logs;
+  unencryptedLogs: CountedLog<UnencryptedL2Log>[];
 }
 
-export function collectNullifiedNoteHashCounters(execResult: ExecutionResult): NullifiedNoteHashCounter[] {
-  return [
-    execResult.nullifiedNoteHashCounters,
-    ...execResult.nestedExecutions.flatMap(collectNullifiedNoteHashCounters),
-  ].flat();
+export function collectNoteHashLeafIndexMap(execResult: ExecutionResult, accum: Map<bigint, bigint> = new Map()) {
+  execResult.noteHashLeafIndexMap.forEach((value, key) => accum.set(key, value));
+  execResult.nestedExecutions.forEach(nested => collectNoteHashLeafIndexMap(nested, accum));
+  return accum;
+}
+
+export function collectNullifiedNoteHashCounters(execResult: ExecutionResult, accum: Map<number, number> = new Map()) {
+  execResult.nullifiedNoteHashCounters.forEach((value, key) => accum.set(key, value));
+  execResult.nestedExecutions.forEach(nested => collectNullifiedNoteHashCounters(nested, accum));
+  return accum;
 }
 
 /**
@@ -74,9 +87,19 @@ export function collectNullifiedNoteHashCounters(execResult: ExecutionResult): N
  * @param execResult - The topmost execution result.
  * @returns All encrypted logs.
  */
-export function collectEncryptedLogs(execResult: ExecutionResult): EncryptedFunctionL2Logs[] {
-  // without the .reverse(), the logs will be in a queue like fashion which is wrong as the kernel processes it like a stack.
-  return [execResult.encryptedLogs, ...[...execResult.nestedExecutions].reverse().flatMap(collectEncryptedLogs)];
+function collectEncryptedLogs(execResult: ExecutionResult): CountedLog<EncryptedL2Log>[] {
+  return [execResult.encryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectEncryptedLogs)].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 collectSortedEncryptedLogs(execResult: ExecutionResult): EncryptedFunctionL2Logs {
+  const allLogs = collectEncryptedLogs(execResult);
+  const sortedLogs = sortByCounter(allLogs);
+  return new EncryptedFunctionL2Logs(sortedLogs.map(l => l.log));
 }
 
 /**
@@ -84,9 +107,19 @@ export function collectEncryptedLogs(execResult: ExecutionResult): EncryptedFunc
  * @param execResult - The topmost execution result.
  * @returns All unencrypted logs.
  */
-export function collectUnencryptedLogs(execResult: ExecutionResult): UnencryptedFunctionL2Logs[] {
-  // without the .reverse(), the logs will be in a queue like fashion which is wrong as the kernel processes it like a stack.
-  return [execResult.unencryptedLogs, ...[...execResult.nestedExecutions].reverse().flatMap(collectUnencryptedLogs)];
+function collectUnencryptedLogs(execResult: ExecutionResult): CountedLog<UnencryptedL2Log>[] {
+  return [execResult.unencryptedLogs, ...[...execResult.nestedExecutions].flatMap(collectUnencryptedLogs)].flat();
+}
+
+/**
+ * Collect all unencrypted logs across all nested executions and sorts by counter.
+ * @param execResult - The topmost execution result.
+ * @returns All unencrypted logs.
+ */
+export function collectSortedUnencryptedLogs(execResult: ExecutionResult): UnencryptedFunctionL2Logs {
+  const allLogs = collectUnencryptedLogs(execResult);
+  const sortedLogs = sortByCounter(allLogs);
+  return new UnencryptedFunctionL2Logs(sortedLogs.map(l => l.log));
 }
 
 /**
@@ -99,6 +132,23 @@ export function collectEnqueuedPublicFunctionCalls(execResult: ExecutionResult):
   // as the kernel processes it like a stack, popping items off and pushing them to output
   return [
     ...execResult.enqueuedPublicFunctionCalls,
-    ...[...execResult.nestedExecutions].flatMap(collectEnqueuedPublicFunctionCalls),
+    ...execResult.nestedExecutions.flatMap(collectEnqueuedPublicFunctionCalls),
   ].sort((a, b) => b.callContext.sideEffectCounter - a.callContext.sideEffectCounter);
 }
+
+export function collectPublicTeardownFunctionCall(execResult: ExecutionResult): PublicCallRequest {
+  const teardownCalls = [
+    execResult.publicTeardownFunctionCall,
+    ...execResult.nestedExecutions.flatMap(collectPublicTeardownFunctionCall),
+  ].filter(call => !call.isEmpty());
+
+  if (teardownCalls.length === 1) {
+    return teardownCalls[0];
+  }
+
+  if (teardownCalls.length > 1) {
+    throw new Error('Multiple public teardown calls detected');
+  }
+
+  return PublicCallRequest.empty();
+}

package/src/client/logs_cache.ts

@@ -0,0 +1,65 @@
+import { type EncryptedL2Log, type UnencryptedL2Log } from '@aztec/circuit-types';
+
+/**
+ * Log data that's accessible by all the function calls in an execution.
+ * This class exists to:
+ * 1. Keep track of logs emitted through nested calls in the correct order.
+ * 2. TODO(1641): Remove encrypted logs based on notes nullified in the same scope.
+ */
+export class LogsCache {
+  /**
+   * Logs notes created in this transaction.
+   */
+  private encryptedLogs: EncryptedL2Log[] = [];
+  private unencryptedLogs: UnencryptedL2Log[] = [];
+
+  // TODO Separate encrypted logs linked to note hashes and arbitrary logs:
+
+  // Maps from note hash to encrypted log - useful for removing transient logs
+  // private encryptedLogsLinkedToNotes: Map<bigint, EncryptedL2Log> = new Map();
+
+  // /**
+  //  * Remove the encrypted log for a nullified note.
+  //  * This fn should only be called if the note's innerNoteHash != 0.
+  //  * @param noteHashCounter - Side effect counter of the note.
+  //  */
+  // public nullifyNote(noteHashCounter: Fr) {
+  //  // Find and remove the matching new note if the emitted innerNoteHash is not empty.
+  //  const log = this.encryptedLogsLinkedToNotes.get(noteHashCounter.toBigInt()) ?? false;
+  //  // TODO: throw here? Will the log always be here?
+  //  if (!log) {
+  //    throw new Error('Attempt to remove a pending note log that does not exist.');
+  //  }
+  //  this.encryptedLogsLinkedToNotes.delete(noteHashCounter.toBigInt());
+  // }
+
+  /**
+   * Add a new encrypted log to cache.
+   * @param log - New log created during execution.
+   */
+  public addEncryptedLog(log: EncryptedL2Log) {
+    this.encryptedLogs.push(log);
+  }
+
+  /**
+   * Add a new unencrypted log to cache.
+   * @param log - New log created during execution.
+   */
+  public addUnencryptedLog(log: UnencryptedL2Log) {
+    this.unencryptedLogs.push(log);
+  }
+
+  /**
+   * Return the encrypted logs.
+   */
+  public getEncryptedLogs() {
+    return this.encryptedLogs;
+  }
+
+  /**
+   * Return the encrypted logs.
+   */
+  public getUnencryptedLogs() {
+    return this.unencryptedLogs;
+  }
+}

package/src/client/private_execution.ts

@@ -1,7 +1,6 @@
 import { type FunctionData, PrivateCallStackItem, PrivateCircuitPublicInputs } from '@aztec/circuits.js';
-import { type FunctionArtifactWithDebugMetadata } from '@aztec/foundation/abi';
+import { type FunctionArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { witnessMapToFields } from '../acvm/deserialize.js';
@@ -16,7 +15,7 @@ import { AcirSimulator } from './simulator.js';
  */
 export async function executePrivateFunction(
   context: ClientExecutionContext,
-  artifact: FunctionArtifactWithDebugMetadata,
+  artifact: FunctionArtifact,
   contractAddress: AztecAddress,
   functionData: FunctionData,
   log = createDebugLogger('aztec:simulator:secret_execution'),
@@ -45,21 +44,17 @@ export async function executePrivateFunction(
 
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
-  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
-  publicInputs.encryptedLogPreimagesLength = new Fr(encryptedLogs.getSerializedLength());
-  publicInputs.unencryptedLogPreimagesLength = new Fr(unencryptedLogs.getSerializedLength());
 
   const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);
 
   const rawReturnValues = await context.unpackReturns(publicInputs.returnsHash);
 
-  const noteHashReadRequestPartialWitnesses = context.getNoteHashReadRequestPartialWitnesses(
-    publicInputs.noteHashReadRequests,
-  );
+  const noteHashLeafIndexMap = context.getNoteHashLeafIndexMap();
   const newNotes = context.getNewNotes();
   const nullifiedNoteHashCounters = context.getNullifiedNoteHashCounters();
   const nestedExecutions = context.getNestedExecutions();
   const enqueuedPublicFunctionCalls = context.getEnqueuedPublicFunctionCalls();
+  const publicTeardownFunctionCall = context.getPublicTeardownFunctionCall();
 
   log.debug(`Returning from call to ${contractAddress.toString()}:${functionSelector}`);
 
@@ -68,12 +63,13 @@ export async function executePrivateFunction(
     partialWitness,
     callStackItem,
     returnValues: rawReturnValues,
-    noteHashReadRequestPartialWitnesses,
+    noteHashLeafIndexMap,
     newNotes,
     nullifiedNoteHashCounters,
     vk: Buffer.from(artifact.verificationKey!, 'hex'),
     nestedExecutions,
     enqueuedPublicFunctionCalls,
+    publicTeardownFunctionCall,
     encryptedLogs,
     unencryptedLogs,
   };

package/src/client/simulator.ts

@@ -2,7 +2,7 @@ import { type AztecNode, type FunctionCall, type Note, type TxExecutionRequest }
 import { CallContext, FunctionData } from '@aztec/circuits.js';
 import {
   type ArrayType,
-  type FunctionArtifactWithDebugMetadata,
+  type FunctionArtifact,
   FunctionSelector,
   FunctionType,
   encodeArguments,
@@ -19,6 +19,7 @@ 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';
@@ -64,7 +65,7 @@ export class AcirSimulator {
    */
   public async run(
     request: TxExecutionRequest,
-    entryPointArtifact: FunctionArtifactWithDebugMetadata,
+    entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
     msgSender = AztecAddress.ZERO,
   ): Promise<ExecutionResult> {
@@ -100,6 +101,7 @@ export class AcirSimulator {
       request.authWitnesses,
       PackedValuesCache.create(request.argsOfCalls),
       new ExecutionNoteCache(),
+      new LogsCache(),
       this.db,
       this.node,
       startSideEffectCounter,
@@ -127,7 +129,7 @@ export class AcirSimulator {
    */
   public async runUnconstrained(
     request: FunctionCall,
-    entryPointArtifact: FunctionArtifactWithDebugMetadata,
+    entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
   ) {
     if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
@@ -165,7 +167,7 @@ export class AcirSimulator {
     noteTypeId: Fr,
     note: Note,
   ) {
-    const artifact: FunctionArtifactWithDebugMetadata | undefined = await this.db.getFunctionArtifactByName(
+    const artifact: FunctionArtifact | undefined = await this.db.getFunctionArtifactByName(
       contractAddress,
       'compute_note_hash_and_nullifier',
     );
@@ -198,7 +200,7 @@ export class AcirSimulator {
       args: encodeArguments(artifact, [contractAddress, nonce, storageSlot, noteTypeId, extendedNoteItems]),
     };
 
-    const [innerNoteHash, siloedNoteHash, uniqueSiloedNoteHash, innerNullifier] = (await this.runUnconstrained(
+    const [innerNoteHash, uniqueNoteHash, siloedNoteHash, innerNullifier] = (await this.runUnconstrained(
       execRequest,
       artifact,
       contractAddress,
@@ -206,8 +208,8 @@ export class AcirSimulator {
 
     return {
       innerNoteHash: new Fr(innerNoteHash),
+      uniqueNoteHash: new Fr(uniqueNoteHash),
       siloedNoteHash: new Fr(siloedNoteHash),
-      uniqueSiloedNoteHash: new Fr(uniqueSiloedNoteHash),
       innerNullifier: new Fr(innerNullifier),
     };
   }
@@ -230,82 +232,4 @@ export class AcirSimulator {
     );
     return innerNoteHash;
   }
-
-  /**
-   * Computes the unique note hash of a note.
-   * @param contractAddress - The address of the contract.
-   * @param nonce - The nonce of the note hash.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param note - The note.
-   * @returns The note hash.
-   */
-  public async computeUniqueSiloedNoteHash(
-    contractAddress: AztecAddress,
-    nonce: Fr,
-    storageSlot: Fr,
-    noteTypeId: Fr,
-    note: Note,
-  ) {
-    const { uniqueSiloedNoteHash } = await this.computeNoteHashAndNullifier(
-      contractAddress,
-      nonce,
-      storageSlot,
-      noteTypeId,
-      note,
-    );
-    return uniqueSiloedNoteHash;
-  }
-
-  /**
-   * Computes the siloed note hash of a note.
-   * @param contractAddress - The address of the contract.
-   * @param nonce - The nonce of the note hash.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param note - The note.
-   * @returns The note hash.
-   */
-  public async computeSiloedNoteHash(
-    contractAddress: AztecAddress,
-    nonce: Fr,
-    storageSlot: Fr,
-    noteTypeId: Fr,
-    note: Note,
-  ) {
-    const { siloedNoteHash } = await this.computeNoteHashAndNullifier(
-      contractAddress,
-      nonce,
-      storageSlot,
-      noteTypeId,
-      note,
-    );
-    return siloedNoteHash;
-  }
-
-  /**
-   * Computes the inner note hash of a note, which contains storage slot and the custom note hash.
-   * @param contractAddress - The address of the contract.
-   * @param nonce - The nonce of the unique note hash.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param note - The note.
-   * @returns The note hash.
-   */
-  public async computeInnerNullifier(
-    contractAddress: AztecAddress,
-    nonce: Fr,
-    storageSlot: Fr,
-    noteTypeId: Fr,
-    note: Note,
-  ) {
-    const { innerNullifier } = await this.computeNoteHashAndNullifier(
-      contractAddress,
-      nonce,
-      storageSlot,
-      noteTypeId,
-      note,
-    );
-    return innerNullifier;
-  }
 }

package/src/client/unconstrained_execution.ts

@@ -1,5 +1,5 @@
 import { type FunctionData } from '@aztec/circuits.js';
-import { type DecodedReturn, type FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/foundation/abi';
+import { type DecodedReturn, type FunctionArtifact, decodeReturnValues } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -16,7 +16,7 @@ import { type ViewDataOracle } from './view_data_oracle.js';
  */
 export async function executeUnconstrainedFunction(
   oracle: ViewDataOracle,
-  artifact: FunctionArtifactWithDebugMetadata,
+  artifact: FunctionArtifact,
   contractAddress: AztecAddress,
   functionData: FunctionData,
   args: Fr[],

package/src/client/view_data_oracle.ts

@@ -166,16 +166,6 @@ export class ViewDataOracle extends TypedOracle {
     return this.db.popCapsule();
   }
 
-  /**
-   * Gets public keys for an address.
-   * @param The address to look up
-   * @returns The public keys for a specific address
-   * TODO(#5834): Replace with `getCompleteAddress`.
-   */
-  public override getPublicKeysForAddress(address: AztecAddress) {
-    return this.db.getPublicKeysForAddress(address);
-  }
-
   /**
    * Gets some notes for a contract address and storage slot.
    * Returns a flattened array containing filtered notes.

package/src/common/errors.ts

@@ -2,6 +2,11 @@ import { type FailingFunction, type NoirCallStack, SimulationError } from '@azte
 
 /**
  * An error that occurred during the execution of a function.
+ * @param message - the error message
+ * @param failingFunction - the Aztec function that failed
+ * @param noirCallStack - the internal call stack of the function that failed (within the failing Aztec function)
+ * @param options - additional error options (an optional "cause" entry allows for a recursive error stack where
+ *                  an error's cause may be an ExecutionError itself)
  */
 export class ExecutionError extends Error {
   constructor(

package/src/index.ts

@@ -4,3 +4,4 @@ export * from './common/index.js';
 export * from './public/index.js';
 export * from './simulator/index.js';
 export * from './mocks/index.js';
+export * from './stats/index.js';

package/src/mocks/fixtures.ts

@@ -116,6 +116,8 @@ export class PublicExecutionResultBuilder {
       contractStorageReads: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
+      unencryptedLogPreimagesLength: new Fr(4n), // empty logs have len 4
+      allUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       startSideEffectCounter: Fr.ZERO,
       endSideEffectCounter: Fr.ZERO,
       reverted: this._reverted,