@aztec/simulator 0.43.0 → 0.45.0

package/src/avm/journal/journal.ts

@@ -1,139 +1,70 @@
-// TODO(5818): Rename file and all uses of "journal"
-import { UnencryptedL2Log } from '@aztec/circuit-types';
-import {
-  AztecAddress,
-  ContractStorageRead,
-  ContractStorageUpdateRequest,
-  EthAddress,
-  L2ToL1Message,
-  LogHash,
-  NoteHash,
-  Nullifier,
-  ReadRequest,
-} from '@aztec/circuits.js';
-import { EventSelector } from '@aztec/foundation/abi';
-import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress, type FunctionSelector, type Gas } from '@aztec/circuits.js';
+import { type Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { SerializableContractInstance } from '@aztec/types/contracts';
 
-import { type PublicExecutionResult } from '../../index.js';
+import { type TracedContractInstance } from '../../public/side_effect_trace.js';
+import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
+import { type AvmContractCallResult } from '../avm_contract_call_result.js';
+import { type AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { type HostStorage } from './host_storage.js';
-import { Nullifiers } from './nullifiers.js';
+import { NullifierManager } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
-import { WorldStateAccessTrace } from './trace.js';
-import {
-  type TracedContractInstance,
-  type TracedL1toL2MessageCheck,
-  type TracedNoteHash,
-  type TracedNoteHashCheck,
-  type TracedNullifier,
-  type TracedNullifierCheck,
-  type TracedPublicStorageRead,
-  type TracedPublicStorageWrite,
-  type TracedUnencryptedL2Log,
-} from './trace_types.js';
-
-// TODO:(5818): do we need this type anymore?
-/**
- * Data held within the journal
- */
-export type JournalData = {
-  storageWrites: TracedPublicStorageWrite[];
-  storageReads: TracedPublicStorageRead[];
-
-  noteHashChecks: TracedNoteHashCheck[];
-  newNoteHashes: TracedNoteHash[];
-  nullifierChecks: TracedNullifierCheck[];
-  newNullifiers: TracedNullifier[];
-  l1ToL2MessageChecks: TracedL1toL2MessageCheck[];
-
-  newL1Messages: L2ToL1Message[];
-  newLogs: UnencryptedL2Log[];
-  newLogsHashes: TracedUnencryptedL2Log[];
-  /** contract address -\> key -\> value */
-  currentStorageValue: Map<bigint, Map<bigint, Fr>>;
-
-  sideEffectCounter: number;
-};
-
-// TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-export type PartialPublicExecutionResult = {
-  noteHashReadRequests: ReadRequest[];
-  nullifierReadRequests: ReadRequest[];
-  nullifierNonExistentReadRequests: ReadRequest[];
-  l1ToL2MsgReadRequests: ReadRequest[];
-  newNoteHashes: NoteHash[];
-  newL2ToL1Messages: L2ToL1Message[];
-  startSideEffectCounter: number;
-  newNullifiers: Nullifier[];
-  contractStorageReads: ContractStorageRead[];
-  contractStorageUpdateRequests: ContractStorageUpdateRequest[];
-  unencryptedLogsHashes: LogHash[];
-  unencryptedLogs: UnencryptedL2Log[];
-  allUnencryptedLogs: UnencryptedL2Log[];
-  nestedExecutions: PublicExecutionResult[];
-};
 
 /**
  * A class to manage persistable AVM state for contract calls.
  * Maintains a cache of the current world state,
- * a trace of all world state accesses, and a list of accrued substate items.
+ * a trace of all side effects.
  *
- * The simulator should make any world state and accrued substate queries through this object.
+ * The simulator should make any world state / tree queries through this object.
  *
  * Manages merging of successful/reverted child state into current state.
  */
 export class AvmPersistableStateManager {
   private readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:state_manager');
-  /** Reference to node storage */
-  public readonly hostStorage: HostStorage;
-
-  // TODO(5818): make members private once this is not used in transitional_adaptors.ts.
-  /** World State */
-  /** Public storage, including cached writes */
-  public publicStorage: PublicStorage;
-  /** Nullifier set, including cached/recently-emitted nullifiers */
-  public nullifiers: Nullifiers;
 
-  /** World State Access Trace */
-  public trace: WorldStateAccessTrace;
+  constructor(
+    /** Reference to node storage */
+    private readonly hostStorage: HostStorage,
+    /** Side effect trace */
+    private readonly trace: PublicSideEffectTraceInterface,
+    /** Public storage, including cached writes */
+    // TODO(5818): make private once no longer accessed in executor
+    public readonly publicStorage: PublicStorage,
+    /** Nullifier set, including cached/recently-emitted nullifiers */
+    private readonly nullifiers: NullifierManager,
+  ) {}
 
-  /** Accrued Substate **/
-  public newL1Messages: L2ToL1Message[] = [];
-  public newLogs: UnencryptedL2Log[] = [];
-
-  // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-  public transitionalExecutionResult: PartialPublicExecutionResult;
-
-  constructor(hostStorage: HostStorage, parent?: AvmPersistableStateManager) {
-    this.hostStorage = hostStorage;
-    this.publicStorage = new PublicStorage(hostStorage.publicStateDb, parent?.publicStorage);
-    this.nullifiers = new Nullifiers(hostStorage.commitmentsDb, parent?.nullifiers);
-    this.trace = new WorldStateAccessTrace(parent?.trace);
-
-    this.transitionalExecutionResult = {
-      noteHashReadRequests: [],
-      nullifierReadRequests: [],
-      nullifierNonExistentReadRequests: [],
-      l1ToL2MsgReadRequests: [],
-      newNoteHashes: [],
-      newL2ToL1Messages: [],
-      startSideEffectCounter: this.trace.accessCounter,
-      newNullifiers: [],
-      contractStorageReads: [],
-      contractStorageUpdateRequests: [],
-      unencryptedLogsHashes: [],
-      unencryptedLogs: [],
-      allUnencryptedLogs: [],
-      nestedExecutions: [],
-    };
+  /**
+   * Create a new state manager with some preloaded pending siloed nullifiers
+   */
+  public static newWithPendingSiloedNullifiers(
+    hostStorage: HostStorage,
+    trace: PublicSideEffectTraceInterface,
+    pendingSiloedNullifiers: Fr[],
+  ) {
+    const parentNullifiers = NullifierManager.newWithPendingSiloedNullifiers(
+      hostStorage.commitmentsDb,
+      pendingSiloedNullifiers,
+    );
+    return new AvmPersistableStateManager(
+      hostStorage,
+      trace,
+      /*publicStorage=*/ new PublicStorage(hostStorage.publicStateDb),
+      /*nullifiers=*/ parentNullifiers.fork(),
+    );
   }
 
   /**
    * Create a new state manager forked from this one
    */
   public fork() {
-    return new AvmPersistableStateManager(this.hostStorage, this);
+    return new AvmPersistableStateManager(
+      this.hostStorage,
+      this.trace.fork(),
+      this.publicStorage.fork(),
+      this.nullifiers.fork(),
+    );
   }
 
   /**
@@ -147,13 +78,6 @@ export class AvmPersistableStateManager {
     this.log.debug(`Storage write (address=${storageAddress}, slot=${slot}): value=${value}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(storageAddress, slot, value);
-
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.contractStorageUpdateRequests.push(
-      new ContractStorageUpdateRequest(slot, value, this.trace.accessCounter, storageAddress),
-    );
-
-    // Trace all storage writes (even reverted ones)
     this.trace.tracePublicStorageWrite(storageAddress, slot, value);
   }
 
@@ -169,14 +93,22 @@ export class AvmPersistableStateManager {
     this.log.debug(
       `Storage read  (address=${storageAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
     );
+    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
+    return Promise.resolve(value);
+  }
 
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.contractStorageReads.push(
-      new ContractStorageRead(slot, value, this.trace.accessCounter, storageAddress),
+  /**
+   * Read from public storage, don't trace the read.
+   *
+   * @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 the latest value written to slot, or 0 if never written to before
+   */
+  public async peekStorage(storageAddress: Fr, slot: Fr): Promise<Fr> {
+    const { value, exists, cached } = await this.publicStorage.read(storageAddress, slot);
+    this.log.debug(
+      `Storage peek  (address=${storageAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
     );
-
-    // We want to keep track of all performed reads (even reverted ones)
-    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
     return Promise.resolve(value);
   }
 
@@ -193,11 +125,7 @@ export class AvmPersistableStateManager {
     const gotLeafIndex = await this.hostStorage.commitmentsDb.getCommitmentIndex(noteHash);
     const exists = gotLeafIndex === leafIndex.toBigInt();
     this.log.debug(`noteHashes(${storageAddress})@${noteHash} ?? leafIndex: ${leafIndex}, exists: ${exists}.`);
-
-    // TODO: include exists here also - This can for sure come from the trace???
-    this.transitionalExecutionResult.noteHashReadRequests.push(new ReadRequest(noteHash, this.trace.accessCounter));
-
-    this.trace.traceNoteHashCheck(storageAddress, noteHash, exists, leafIndex);
+    this.trace.traceNoteHashCheck(storageAddress, noteHash, leafIndex, exists);
     return Promise.resolve(exists);
   }
 
@@ -206,9 +134,6 @@ export class AvmPersistableStateManager {
    * @param noteHash - the unsiloed note hash to write
    */
   public writeNoteHash(storageAddress: Fr, noteHash: Fr) {
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.newNoteHashes.push(new NoteHash(noteHash, this.trace.accessCounter));
-
     this.log.debug(`noteHashes(${storageAddress}) += @${noteHash}.`);
     this.trace.traceNewNoteHash(storageAddress, noteHash);
   }
@@ -222,19 +147,9 @@ export class AvmPersistableStateManager {
   public async checkNullifierExists(storageAddress: Fr, nullifier: Fr): Promise<boolean> {
     const [exists, isPending, leafIndex] = await this.nullifiers.checkExists(storageAddress, nullifier);
     this.log.debug(
-      `nullifiers(${storageAddress})@${nullifier} ?? leafIndex: ${leafIndex}, pending: ${isPending}, exists: ${exists}.`,
+      `nullifiers(${storageAddress})@${nullifier} ?? leafIndex: ${leafIndex}, exists: ${exists}, pending: ${isPending}.`,
     );
-
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    if (exists) {
-      this.transitionalExecutionResult.nullifierReadRequests.push(new ReadRequest(nullifier, this.trace.accessCounter));
-    } else {
-      this.transitionalExecutionResult.nullifierNonExistentReadRequests.push(
-        new ReadRequest(nullifier, this.trace.accessCounter),
-      );
-    }
-
-    this.trace.traceNullifierCheck(storageAddress, nullifier, exists, isPending, leafIndex);
+    this.trace.traceNullifierCheck(storageAddress, nullifier, leafIndex, exists, isPending);
     return Promise.resolve(exists);
   }
 
@@ -244,11 +159,6 @@ export class AvmPersistableStateManager {
    * @param nullifier - the unsiloed nullifier to write
    */
   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, /*noteHash=*/ Fr.ZERO),
-    );
-
     this.log.debug(`nullifiers(${storageAddress}) += ${nullifier}.`);
     // Cache pending nullifiers for later access
     await this.nullifiers.append(storageAddress, nullifier);
@@ -262,16 +172,13 @@ export class AvmPersistableStateManager {
    * @param msgLeafIndex - the message leaf index to use in the check
    * @returns exists - whether the message exists in the L1 to L2 Messages tree
    */
-  public async checkL1ToL2MessageExists(msgHash: Fr, msgLeafIndex: Fr): Promise<boolean> {
+  public async checkL1ToL2MessageExists(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr): Promise<boolean> {
     const valueAtIndex = await this.hostStorage.commitmentsDb.getL1ToL2LeafValue(msgLeafIndex.toBigInt());
     const exists = valueAtIndex?.equals(msgHash) ?? false;
     this.log.debug(
       `l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`,
     );
-
-    this.transitionalExecutionResult.l1ToL2MsgReadRequests.push(new ReadRequest(msgHash, this.trace.accessCounter));
-
-    this.trace.traceL1ToL2MessageCheck(msgHash, msgLeafIndex, exists);
+    this.trace.traceL1ToL2MessageCheck(contractAddress, msgHash, msgLeafIndex, exists);
     return Promise.resolve(exists);
   }
 
@@ -280,40 +187,27 @@ export class AvmPersistableStateManager {
    * @param recipient - L1 contract address to send the message to.
    * @param content - Message content.
    */
-  public writeL1Message(recipient: EthAddress | Fr, content: Fr) {
+  public writeL2ToL1Message(recipient: Fr, content: Fr) {
     this.log.debug(`L1Messages(${recipient}) += ${content}.`);
-    const recipientAddress = recipient instanceof EthAddress ? recipient : EthAddress.fromField(recipient);
-    const message = new L2ToL1Message(recipientAddress, content, 0);
-    this.newL1Messages.push(message);
-
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.newL2ToL1Messages.push(message);
+    this.trace.traceNewL2ToL1Message(recipient, content);
   }
 
-  public writeLog(contractAddress: Fr, event: Fr, log: Fr[]) {
-    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event ${event} with ${log.length} fields.`);
-    const ulog = new UnencryptedL2Log(
-      AztecAddress.fromField(contractAddress),
-      EventSelector.fromField(event),
-      Buffer.concat(log.map(f => f.toBuffer())),
-    );
-    const logHash = Fr.fromBuffer(ulog.hash());
-
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.unencryptedLogs.push(ulog);
-    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(
-      // TODO(6578): explain magic number 4 here
-      new LogHash(logHash, this.trace.accessCounter, new Fr(ulog.length + 4)),
-    );
-    // TODO(6206): likely need to track this here and not just in the transitional logic.
-
-    // TODO(6205): why are logs pushed here but logs hashes are traced?
-    this.newLogs.push(ulog);
-    this.trace.traceNewLog(logHash);
+  /**
+   * Write an unencrypted log
+   * @param contractAddress - address of the contract that emitted the log
+   * @param event - log event selector
+   * @param log - log contents
+   */
+  public writeUnencryptedLog(contractAddress: Fr, log: Fr[]) {
+    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event with ${log.length} fields.`);
+    this.trace.traceUnencryptedLog(contractAddress, log);
   }
 
+  /**
+   * Get a contract instance.
+   * @param contractAddress - address of the contract instance to retrieve.
+   * @returns the contract instance with an "exists" flag
+   */
   public async getContractInstance(contractAddress: Fr): Promise<TracedContractInstance> {
     let exists = true;
     const aztecAddress = AztecAddress.fromField(contractAddress);
@@ -322,59 +216,59 @@ export class AvmPersistableStateManager {
       instance = SerializableContractInstance.empty().withAddress(aztecAddress);
       exists = false;
     }
+    this.log.debug(
+      `Get Contract instance (address=${contractAddress}): exists=${exists}, instance=${JSON.stringify(instance)}`,
+    );
     const tracedInstance = { ...instance, exists };
     this.trace.traceGetContractInstance(tracedInstance);
     return Promise.resolve(tracedInstance);
   }
 
   /**
-   * Accept nested world state modifications, merging in its trace and accrued substate
+   * Accept nested world state modifications
    */
-  public acceptNestedCallState(nestedJournal: AvmPersistableStateManager) {
-    // Merge Public Storage
-    this.publicStorage.acceptAndMerge(nestedJournal.publicStorage);
-
-    // Merge World State Access Trace
-    this.trace.acceptAndMerge(nestedJournal.trace);
-
-    // Accrued Substate
-    this.newL1Messages.push(...nestedJournal.newL1Messages);
-    this.newLogs.push(...nestedJournal.newLogs);
-
-    // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
-    this.transitionalExecutionResult.allUnencryptedLogs.push(
-      ...nestedJournal.transitionalExecutionResult.allUnencryptedLogs,
-    );
+  public acceptNestedCallState(nestedState: AvmPersistableStateManager) {
+    this.publicStorage.acceptAndMerge(nestedState.publicStorage);
+    this.nullifiers.acceptAndMerge(nestedState.nullifiers);
   }
 
   /**
-   * Reject nested world state, merging in its trace, but not accepting any state modifications
+   * Get a contract's bytecode from the contracts DB
    */
-  public rejectNestedCallState(nestedJournal: AvmPersistableStateManager) {
-    // Merge World State Access Trace
-    this.trace.acceptAndMerge(nestedJournal.trace);
+  public async getBytecode(contractAddress: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
+    return await this.hostStorage.contractsDb.getBytecode(contractAddress, selector);
   }
 
-  // TODO:(5818): do we need this type anymore?
   /**
-   * Access the current state of the journal
-   *
-   * @returns a JournalData object
+   * Accept the nested call's state and trace the nested call
    */
-  public flush(): JournalData {
-    return {
-      noteHashChecks: this.trace.noteHashChecks,
-      newNoteHashes: this.trace.newNoteHashes,
-      nullifierChecks: this.trace.nullifierChecks,
-      newNullifiers: this.trace.newNullifiers,
-      l1ToL2MessageChecks: this.trace.l1ToL2MessageChecks,
-      newL1Messages: this.newL1Messages,
-      newLogs: this.newLogs,
-      newLogsHashes: this.trace.newLogsHashes,
-      currentStorageValue: this.publicStorage.getCache().cachePerContract,
-      storageReads: this.trace.publicStorageReads,
-      storageWrites: this.trace.publicStorageWrites,
-      sideEffectCounter: this.trace.accessCounter,
-    };
+  public async processNestedCall(
+    nestedState: AvmPersistableStateManager,
+    nestedEnvironment: AvmExecutionEnvironment,
+    startGasLeft: Gas,
+    endGasLeft: Gas,
+    bytecode: Buffer,
+    avmCallResults: AvmContractCallResult,
+  ) {
+    if (!avmCallResults.reverted) {
+      this.acceptNestedCallState(nestedState);
+    }
+    const functionName =
+      (await nestedState.hostStorage.contractsDb.getDebugFunctionName(
+        nestedEnvironment.address,
+        nestedEnvironment.functionSelector,
+      )) ?? `${nestedEnvironment.address}:${nestedEnvironment.functionSelector}`;
+
+    this.log.verbose(`[AVM] Calling nested function ${functionName}`);
+
+    this.trace.traceNestedCall(
+      nestedState.trace,
+      nestedEnvironment,
+      startGasLeft,
+      endGasLeft,
+      bytecode,
+      avmCallResults,
+      functionName,
+    );
   }
 }

package/src/avm/journal/nullifiers.ts

@@ -9,17 +9,29 @@ import type { CommitmentsDB } from '../../index.js';
  * Maintains a nullifier cache, and ensures that existence checks fall back to the correct source.
  * When a contract call completes, its cached nullifier set can be merged into its parent's.
  */
-export class Nullifiers {
-  /** Cached nullifiers. */
-  public cache: NullifierCache;
-
+export class NullifierManager {
   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();
+    /** Cached nullifiers. */
+    private readonly cache: NullifierCache = new NullifierCache(),
+    /** Parent nullifier manager to fall back on */
+    private readonly parent?: NullifierManager,
+  ) {}
+
+  /**
+   * Create a new nullifiers manager with some preloaded pending siloed nullifiers
+   */
+  public static newWithPendingSiloedNullifiers(hostNullifiers: CommitmentsDB, pendingSiloedNullifiers: Fr[]) {
+    const cache = new NullifierCache(pendingSiloedNullifiers);
+    return new NullifierManager(hostNullifiers, cache);
+  }
+
+  /**
+   * Create a new nullifiers manager forked from this one
+   */
+  public fork() {
+    return new NullifierManager(this.hostNullifiers, new NullifierCache(), this);
   }
 
   /**
@@ -92,7 +104,7 @@ export class Nullifiers {
    *
    * @param incomingNullifiers - the incoming cached nullifiers to merge into this instance's
    */
-  public acceptAndMerge(incomingNullifiers: Nullifiers) {
+  public acceptAndMerge(incomingNullifiers: NullifierManager) {
     this.cache.acceptAndMerge(incomingNullifiers.cache);
   }
 }
@@ -111,6 +123,15 @@ export class NullifierCache {
   private cachePerContract: Map<bigint, Set<bigint>> = new Map();
   private siloedNullifiers: Set<bigint> = new Set();
 
+  /**
+   * @parem siloedNullifierFrs: optional list of pending siloed nullifiers to initialize this cache with
+   */
+  constructor(siloedNullifierFrs?: Fr[]) {
+    if (siloedNullifierFrs !== undefined) {
+      siloedNullifierFrs.forEach(nullifier => this.siloedNullifiers.add(nullifier.toBigInt()));
+    }
+  }
+
   /**
    * Check whether a nullifier exists in the cache.
    *
@@ -147,10 +168,6 @@ export class NullifierCache {
     nullifiersForContract.add(nullifier.toBigInt());
   }
 
-  public appendSiloed(siloedNullifier: Fr) {
-    this.siloedNullifiers.add(siloedNullifier.toBigInt());
-  }
-
   /**
    * Merge another cache's nullifiers into this instance's.
    *

package/src/avm/journal/public_storage.ts

@@ -16,7 +16,7 @@ type PublicStorageReadResult = {
  */
 export class PublicStorage {
   /** Cached storage writes. */
-  private cache: PublicStorageCache;
+  private readonly cache: PublicStorageCache;
 
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
@@ -27,6 +27,13 @@ export class PublicStorage {
     this.cache = new PublicStorageCache();
   }
 
+  /**
+   * Create a new public storage manager forked from this one
+   */
+  public fork() {
+    return new PublicStorage(this.hostPublicStorage, this);
+  }
+
   /**
    * Get the pending storage.
    */
@@ -71,6 +78,9 @@ export class PublicStorage {
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
       value = await this.hostPublicStorage.storageRead(storageAddress, slot);
+      // TODO(dbanks12): if value retrieved from host storage, we can cache it here
+      // any future reads to the same slot can read from cache instead of more expensive
+      // DB access
     } else {
       cached = true;
     }
@@ -124,7 +134,7 @@ class PublicStorageCache {
    * mapping storage slot to latest staged write value.
    */
   public cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
-  // FIXME: storage ^ should be private, but its value is used in tests for "currentStorageValue"
+  // FIXME: storage ^ should be private, but its value is used in commitToDB
 
   /**
    * Read a staged value from storage, if it has been previously written to.

package/src/avm/opcodes/accrued_substate.ts

@@ -201,7 +201,11 @@ export class L1ToL2MessageExists extends Instruction {
 
     const msgHash = memory.get(msgHashOffset).toFr();
     const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
-    const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
+    const exists = await context.persistableState.checkL1ToL2MessageExists(
+      context.environment.address,
+      msgHash,
+      msgLeafIndex,
+    );
     memory.set(existsOffset, exists ? new Uint8(1) : new Uint8(0));
 
     memory.assert(memoryOperations);
@@ -213,20 +217,9 @@ export class EmitUnencryptedLog extends Instruction {
   static type: string = 'EMITUNENCRYPTEDLOG';
   static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
 
-  constructor(
-    private indirect: number,
-    private eventSelectorOffset: number,
-    private logOffset: number,
-    private logSizeOffset: number,
-  ) {
+  constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
     super();
   }
 
@@ -237,22 +230,20 @@ export class EmitUnencryptedLog extends Instruction {
 
     const memory = context.machineState.memory.track(this.type);
 
-    const [eventSelectorOffset, logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.eventSelectorOffset, this.logOffset, this.logSizeOffset],
+    const [logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.logOffset, this.logSizeOffset],
       memory,
     );
-    memory.checkTag(TypeTag.FIELD, eventSelectorOffset);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
     const logSize = memory.get(logSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
 
     const contractAddress = context.environment.address;
-    const event = memory.get(eventSelectorOffset).toFr();
 
-    const memoryOperations = { reads: 2 + logSize, indirect: this.indirect };
+    const memoryOperations = { reads: 1 + logSize, indirect: this.indirect };
     context.machineState.consumeGas(this.gasCost(memoryOperations));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
-    context.persistableState.writeLog(contractAddress, event, log);
+    context.persistableState.writeUnencryptedLog(contractAddress, log);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -285,7 +276,7 @@ export class SendL2ToL1Message extends Instruction {
 
     const recipient = memory.get(recipientOffset).toFr();
     const content = memory.get(contentOffset).toFr();
-    context.persistableState.writeL1Message(recipient, content);
+    context.persistableState.writeL2ToL1Message(recipient, content);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();