@aztec/simulator 0.40.1 → 0.41.0

package/src/avm/journal/journal.ts

@@ -6,10 +6,10 @@ import {
   ContractStorageUpdateRequest,
   EthAddress,
   L2ToL1Message,
+  LogHash,
   NoteHash,
   Nullifier,
   ReadRequest,
-  SideEffect,
 } from '@aztec/circuits.js';
 import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
@@ -64,9 +64,8 @@ type PartialPublicExecutionResult = {
   newNullifiers: Nullifier[];
   contractStorageReads: ContractStorageRead[];
   contractStorageUpdateRequests: ContractStorageUpdateRequest[];
-  unencryptedLogsHashes: SideEffect[];
+  unencryptedLogsHashes: LogHash[];
   unencryptedLogs: UnencryptedL2Log[];
-  unencryptedLogPreimagesLength: Fr;
   allUnencryptedLogs: UnencryptedL2Log[];
   nestedExecutions: PublicExecutionResult[];
 };
@@ -119,8 +118,6 @@ export class AvmPersistableStateManager {
       contractStorageUpdateRequests: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: [],
-      // The length starts at 4 because it will always include the size.
-      unencryptedLogPreimagesLength: new Fr(4),
       allUnencryptedLogs: [],
       nestedExecutions: [],
     };
@@ -141,7 +138,7 @@ export class AvmPersistableStateManager {
    * @param value - the value being written to the slot
    */
   public writeStorage(storageAddress: Fr, slot: Fr, value: Fr) {
-    this.log.debug(`storage(${storageAddress})@${slot} <- ${value}`);
+    this.log.debug(`Storage write (address=${storageAddress}, slot=${slot}): value=${value}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(storageAddress, slot, value);
 
@@ -172,7 +169,9 @@ export class AvmPersistableStateManager {
    */
   public async readStorage(storageAddress: Fr, slot: Fr): Promise<Fr> {
     const { value, exists, cached } = await this.publicStorage.read(storageAddress, slot);
-    this.log.debug(`storage(${storageAddress})@${slot} ?? value: ${value}, exists: ${exists}, cached: ${cached}.`);
+    this.log.debug(
+      `Storage read  (address=${storageAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
+    );
 
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     // The current info to the kernel kernel does not consider cached reads.
@@ -253,7 +252,9 @@ export class AvmPersistableStateManager {
    */
   public async writeNullifier(storageAddress: Fr, nullifier: Fr) {
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.newNullifiers.push(new Nullifier(nullifier, this.trace.accessCounter, Fr.ZERO));
+    this.transitionalExecutionResult.newNullifiers.push(
+      new Nullifier(nullifier, this.trace.accessCounter, /*noteHash=*/ Fr.ZERO),
+    );
 
     this.log.debug(`nullifiers(${storageAddress}) += ${nullifier}.`);
     // Cache pending nullifiers for later access
@@ -307,12 +308,7 @@ export class AvmPersistableStateManager {
     this.transitionalExecutionResult.allUnencryptedLogs.push(ulog);
     // this duplicates exactly what happens in the trace just for the purpose of transitional integration with the kernel
     this.transitionalExecutionResult.unencryptedLogsHashes.push(
-      new SideEffect(logHash, new Fr(this.trace.accessCounter)),
-    );
-    // Duplicates computation performed in public_context.nr::emit_unencrypted_log
-    // 44 = addr (32) + selector (4) + raw log len (4) + processed log len (4).
-    this.transitionalExecutionResult.unencryptedLogPreimagesLength = new Fr(
-      this.transitionalExecutionResult.unencryptedLogPreimagesLength.toNumber() + 44 + log.length * Fr.SIZE_IN_BYTES,
+      new LogHash(logHash, this.trace.accessCounter, new Fr(ulog.length)),
     );
     // TODO(6206): likely need to track this here and not just in the transitional logic.
 

package/src/avm/journal/nullifiers.ts

@@ -12,21 +12,38 @@ import type { CommitmentsDB } from '../../index.js';
 export class Nullifiers {
   /** Cached nullifiers. */
   public cache: NullifierCache;
-  /** Parent's nullifier cache. Checked on cache-miss. */
-  private readonly parentCache: NullifierCache | undefined;
-  /** Reference to node storage. Checked on parent cache-miss. */
-  private readonly hostNullifiers: CommitmentsDB;
 
-  constructor(hostNullifiers: CommitmentsDB, parent?: Nullifiers) {
-    this.hostNullifiers = hostNullifiers;
-    this.parentCache = parent?.cache;
+  constructor(
+    /** Reference to node storage. Checked on parent cache-miss. */
+    private readonly hostNullifiers: CommitmentsDB,
+    /** Parent's nullifiers. Checked on this' cache-miss. */
+    private readonly parent?: Nullifiers | undefined,
+  ) {
     this.cache = new NullifierCache();
   }
 
+  /**
+   * Get a nullifier's existence in this' cache or parent's (recursively).
+   * DOES NOT CHECK HOST STORAGE!
+   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param nullifier - the nullifier to check for
+   * @returns exists: whether the nullifier exists in cache here or in parent's
+   */
+  private checkExistsHereOrParent(storageAddress: Fr, nullifier: Fr): boolean {
+    // First check this cache
+    let existsAsPending = this.cache.exists(storageAddress, nullifier);
+    // Then try parent's nullifier cache
+    if (!existsAsPending && this.parent) {
+      // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
+      existsAsPending = this.parent.checkExistsHereOrParent(storageAddress, nullifier);
+    }
+    return existsAsPending;
+  }
+
   /**
    * Get a nullifier's existence status.
    * 1. Check cache.
-   * 2. Check parent's cache.
+   * 2. Check parent cache.
    * 3. Fall back to the host state.
    * 4. Not found! Nullifier does not exist.
    *
@@ -40,12 +57,8 @@ export class Nullifiers {
     storageAddress: Fr,
     nullifier: Fr,
   ): Promise<[/*exists=*/ boolean, /*isPending=*/ boolean, /*leafIndex=*/ Fr]> {
-    // First check this cache
-    let existsAsPending = this.cache.exists(storageAddress, nullifier);
-    // Then check parent's cache
-    if (!existsAsPending && this.parentCache) {
-      existsAsPending = this.parentCache?.exists(storageAddress, nullifier);
-    }
+    // Check this cache and parent's (recursively)
+    const existsAsPending = this.checkExistsHereOrParent(storageAddress, nullifier);
     // Finally try the host's Aztec state (a trip to the database)
     // If the value is found in the database, it will be associated with a leaf index!
     let leafIndex: bigint | undefined = undefined;

package/src/avm/journal/public_storage.ts

@@ -17,14 +17,13 @@ type PublicStorageReadResult = {
 export class PublicStorage {
   /** Cached storage writes. */
   private cache: PublicStorageCache;
-  /** Parent's storage cache. Checked on cache-miss. */
-  private readonly parentCache: PublicStorageCache | undefined;
-  /** Reference to node storage. Checked on parent cache-miss. */
-  private readonly hostPublicStorage: PublicStateDB;
 
-  constructor(hostPublicStorage: PublicStateDB, parent?: PublicStorage) {
-    this.hostPublicStorage = hostPublicStorage;
-    this.parentCache = parent?.cache;
+  constructor(
+    /** Reference to node storage. Checked on parent cache-miss. */
+    private readonly hostPublicStorage: PublicStateDB,
+    /** Parent's storage. Checked on this' cache-miss. */
+    private readonly parent?: PublicStorage,
+  ) {
     this.cache = new PublicStorageCache();
   }
 
@@ -35,10 +34,29 @@ export class PublicStorage {
     return this.cache;
   }
 
+  /**
+   * Read a storage value from this' cache or parent's (recursively).
+   * DOES NOT CHECK HOST STORAGE!
+   *
+   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns value: the latest value written according to this cache or the parent's. undefined on cache miss.
+   */
+  public readHereOrParent(storageAddress: Fr, slot: Fr): Fr | undefined {
+    // First try check this storage cache
+    let value = this.cache.read(storageAddress, slot);
+    // Then try parent's storage cache
+    if (!value && this.parent) {
+      // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
+      value = this.parent.readHereOrParent(storageAddress, slot);
+    }
+    return value;
+  }
+
   /**
    * Read a value from storage.
    * 1. Check cache.
-   * 2. Check parent's cache.
+   * 2. Check parent cache.
    * 3. Fall back to the host state.
    * 4. Not found! Value has never been written to before. Flag it as non-existent and return value zero.
    *
@@ -48,12 +66,8 @@ export class PublicStorage {
    */
   public async read(storageAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
     let cached = false;
-    // First try check this storage cache
-    let value = this.cache.read(storageAddress, slot);
-    // Then try parent's storage cache (if it exists / written to earlier in this TX)
-    if (!value && this.parentCache) {
-      value = this.parentCache?.read(storageAddress, slot);
-    }
+    // Check this cache and parent's (recursively)
+    let value = this.readHereOrParent(storageAddress, slot);
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
       value = await this.hostPublicStorage.storageRead(storageAddress, slot);
@@ -73,8 +87,8 @@ export class PublicStorage {
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(storageAddress: Fr, key: Fr, value: Fr) {
-    this.cache.write(storageAddress, key, value);
+  public write(storageAddress: Fr, slot: Fr, value: Fr) {
+    this.cache.write(storageAddress, slot, value);
   }
 
   /**

package/src/avm/opcodes/accrued_substate.ts

@@ -1,11 +1,10 @@
 import type { AvmContext } from '../avm_context.js';
 import { Uint8 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
+import { InstructionExecutionError, StaticCallAlterationError } from '../errors.js';
 import { NullifierCollisionError } from '../journal/nullifiers.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
-import { StaticCallStorageAlterError } from './storage.js';
 
 export class NoteHashExists extends Instruction {
   static type: string = 'NOTEHASHEXISTS';
@@ -65,7 +64,7 @@ export class EmitNoteHash extends Instruction {
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const noteHash = memory.get(this.noteHashOffset).toFr();
@@ -125,7 +124,7 @@ export class EmitNullifier extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: 1, indirect: this.indirect };
@@ -210,7 +209,7 @@ export class EmitUnencryptedLog extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: 1 + this.logSize, indirect: this.indirect };
@@ -244,7 +243,7 @@ export class SendL2ToL1Message extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: 2, indirect: this.indirect };

package/src/avm/opcodes/external_calls.ts

@@ -3,7 +3,7 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 
 import { convertAvmResultsToPxResult, createPublicExecution } from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
-import { gasLeftToGas, sumGas } from '../avm_gas.js';
+import { gasLeftToGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { AvmSimulator } from '../avm_simulator.js';
@@ -40,7 +40,7 @@ abstract class ExternalCall extends Instruction {
     // Function selector is temporary since eventually public contract bytecode will be one blob
     // containing all functions, and function selector will become an application-level mechanism
     // (e.g. first few bytes of calldata + compiler-generated jump table)
-    private temporaryFunctionSelectorOffset: number,
+    private functionSelectorOffset: number,
   ) {
     super();
   }
@@ -57,21 +57,30 @@ abstract class ExternalCall extends Instruction {
     const callAddress = memory.getAs<Field>(addrOffset);
     const calldataSize = memory.get(argsSizeOffset).toNumber();
     const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
-    const l2Gas = memory.get(gasOffset).toNumber();
-    const daGas = memory.getAs<Field>(gasOffset + 1).toNumber();
-    const functionSelector = memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
+    const functionSelector = memory.getAs<Field>(this.functionSelectorOffset).toFr();
+    // If we are already in a static call, we propagate the environment.
+    const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
 
-    const allocatedGas = { l2Gas, daGas };
+    // First we consume the gas for this operation.
     const memoryOperations = { reads: calldataSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
-    const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
-    context.machineState.consumeGas(totalGas);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    // Then we consume the gas allocated for the nested call. The excess will be refunded later.
+    // Gas allocation is capped by the amount of gas left in the current context.
+    // We have to do some dancing here because the gas allocation is a field,
+    // but in the machine state we track gas as a number.
+    const allocatedL2Gas = Number(BigIntMin(memory.get(gasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)));
+    const allocatedDaGas = Number(
+      BigIntMin(memory.get(gasOffset + 1).toBigInt(), BigInt(context.machineState.daGasLeft)),
+    );
+    const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
+    context.machineState.consumeGas(allocatedGas);
 
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
       allocatedGas,
-      this.type,
+      callType,
       FunctionSelector.fromField(functionSelector),
     );
     const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
@@ -215,3 +224,8 @@ export class Revert extends Instruction {
     memory.assert(memoryOperations);
   }
 }
+
+/** Returns the smaller of two bigints. */
+function BigIntMin(a: bigint, b: bigint): bigint {
+  return a < b ? a : b;
+}

package/src/avm/opcodes/storage.ts

@@ -3,7 +3,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 { InstructionExecutionError } from '../errors.js';
+import { StaticCallAlterationError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -44,7 +44,7 @@ export class SStore extends BaseStorageInstruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: this.size + 1, indirect: this.indirect };
@@ -100,13 +100,3 @@ export class SLoad extends BaseStorageInstruction {
     memory.assert(memoryOperations);
   }
 }
-
-/**
- * Error is thrown when a static call attempts to alter storage
- */
-export class StaticCallStorageAlterError extends InstructionExecutionError {
-  constructor() {
-    super('Static calls cannot alter storage');
-    this.name = 'StaticCallStorageAlterError';
-  }
-}

package/src/client/client_execution_context.ts

@@ -1,13 +1,11 @@
 import {
   type AuthWitness,
   type AztecNode,
-  EncryptedFunctionL2Logs,
   EncryptedL2Log,
   L1NotePayload,
   Note,
   type NoteStatus,
   TaggedNote,
-  UnencryptedFunctionL2Logs,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
@@ -22,8 +20,8 @@ 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 { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
 import { applyStringFormatting, createDebugLogger } from '@aztec/foundation/log';
 
 import { type NoteData, toACVMWitness } from '../acvm/index.js';
@@ -31,7 +29,6 @@ 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 { pickNotes } from './pick_notes.js';
 import { executePrivateFunction } from './private_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
@@ -59,6 +56,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 encryptedLogs: CountedLog<EncryptedL2Log>[] = [];
   private unencryptedLogs: CountedLog<UnencryptedL2Log>[] = [];
   private nestedExecutions: ExecutionResult[] = [];
@@ -76,7 +74,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,31 +130,51 @@ 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;
+  }
+
+  /**
+   * 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 encrypted logs emitted during this execution and nested executions.
+   * Return the note encrypted logs emitted during this execution and nested executions.
    */
-  public getAllEncryptedLogs() {
-    return new EncryptedFunctionL2Logs(this.logsCache.getEncryptedLogs());
+  public getAllNoteEncryptedLogs() {
+    return this.noteCache.getLogs();
   }
 
   /**
    * Return the encrypted logs emitted during this execution.
    */
-  public getUnencryptedLogs() {
-    return this.unencryptedLogs;
+  public getEncryptedLogs() {
+    return this.encryptedLogs;
   }
 
   /**
-   * Return the unencrypted logs emitted during this execution and nested executions.
+   * Return the encrypted logs emitted during this execution.
    */
-  public getAllUnencryptedLogs() {
-    return new UnencryptedFunctionL2Logs(this.logsCache.getUnencryptedLogs());
+  public getUnencryptedLogs() {
+    return this.unencryptedLogs;
   }
 
   /**
@@ -337,29 +354,53 @@ 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(encryptedData: Buffer, counter: number) {
+    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedData), counter);
+    this.encryptedLogs.push(encryptedLog);
+  }
+
+  /**
+   * Emit encrypted note data
+   * @param noteHash - The note hash.
+   * @param encryptedNote - The encrypted note data.
+   * @param counter - The effects counter.
+   */
+  public override emitEncryptedNoteLog(noteHash: Fr, encryptedNote: Buffer, counter: number) {
+    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedNote), counter);
+    this.noteEncryptedLogs.push(encryptedLog);
+    this.noteCache.addNewLog(encryptedLog, noteHash);
+  }
+
+  /**
+   * 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 ivpk - 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,
+    ivpk: 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();
+
+    // @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);
   }
 
   /**
@@ -368,7 +409,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 +422,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 +436,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 +450,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(
@@ -450,7 +489,6 @@ export class ClientExecutionContext extends ViewDataOracle {
       this.authWitnesses,
       this.packedValuesCache,
       this.noteCache,
-      this.logsCache,
       this.db,
       this.node,
       sideEffectCounter,

package/src/client/db_oracle.ts

@@ -5,13 +5,13 @@ 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 NoteData } from '../acvm/index.js';
 import { type CommitmentsDB } from '../public/db.js';
 
 /**
@@ -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.