@aztec/simulator 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/public/side_effect_trace.ts

@@ -1,53 +1,23 @@
 import {
-  L1_TO_L2_MSG_TREE_HEIGHT,
-  MAX_ENQUEUED_CALLS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MAX_PUBLIC_LOGS_PER_TX,
-  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NOTE_HASH_TREE_HEIGHT,
-  NULLIFIER_TREE_HEIGHT,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  PUBLIC_DATA_TREE_HEIGHT,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
+  PUBLIC_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import {
-  AvmAccumulatedData,
-  AvmAppendTreeHint,
-  AvmCircuitPublicInputs,
-  AvmContractClassHint,
-  AvmContractInstanceHint,
-  AvmEnqueuedCallHint,
-  AvmExecutionHints,
-  AvmNullifierReadTreeHint,
-  AvmNullifierWriteTreeHint,
-  AvmPublicDataReadTreeHint,
-  AvmPublicDataWriteTreeHint,
-  PublicDataUpdateRequest,
-  PublicDataWrite,
-} from '@aztec/stdlib/avm';
+import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type ContractClassWithCommitment, SerializableContractInstance } from '@aztec/stdlib/contract';
-import type { Gas, GasSettings } from '@aztec/stdlib/gas';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import {
-  NoteHash,
-  Nullifier,
-  PrivateToAvmAccumulatedData,
-  PrivateToAvmAccumulatedDataArrayLengths,
-  PublicCallRequest,
-} from '@aztec/stdlib/kernel';
+import { NoteHash, Nullifier } from '@aztec/stdlib/kernel';
 import { PublicLog } from '@aztec/stdlib/logs';
 import { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
-import type { GlobalVariables, TreeSnapshots } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
@@ -55,24 +25,16 @@ import { SideEffectLimitReachedError } from './side_effect_errors.js';
 import type { PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 import { UniqueClassIds } from './unique_class_ids.js';
 
-const emptyPublicDataPath = () => new Array(PUBLIC_DATA_TREE_HEIGHT).fill(Fr.zero());
-const emptyNoteHashPath = () => new Array(NOTE_HASH_TREE_HEIGHT).fill(Fr.zero());
-const emptyNullifierPath = () => new Array(NULLIFIER_TREE_HEIGHT).fill(Fr.zero());
-const emptyL1ToL2MessagePath = () => new Array(L1_TO_L2_MSG_TREE_HEIGHT).fill(Fr.zero());
-
 /**
  * A struct containing just the side effects as regular arrays
  * as opposed to "Tuple" arrays used by circuit public inputs.
  * This struct is helpful for testing and checking array lengths.
  **/
 export type SideEffects = {
-  enqueuedCalls: PublicCallRequest[];
-
   publicDataWrites: PublicDataUpdateRequest[];
   noteHashes: NoteHash[];
   nullifiers: Nullifier[];
   l2ToL1Msgs: ScopedL2ToL1Message[];
-
   publicLogs: PublicLog[];
 };
 
@@ -100,8 +62,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   /** The side effect counter increments with every call to the trace. */
   private sideEffectCounter: number;
 
-  private enqueuedCalls: PublicCallRequest[] = [];
-
   private publicDataWrites: PublicDataUpdateRequest[] = [];
   private protocolPublicDataWritesLength: number = 0;
   private userPublicDataWritesLength: number = 0;
@@ -110,8 +70,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   private l2ToL1Messages: ScopedL2ToL1Message[] = [];
   private publicLogs: PublicLog[] = [];
 
-  private avmCircuitHints: AvmExecutionHints;
-
   /** Make sure a forked trace is never merged twice. */
   private alreadyMergedIntoParent = false;
 
@@ -124,9 +82,9 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     private readonly previousSideEffectArrayLengths: SideEffectArrayLengths = SideEffectArrayLengths.empty(),
     /** We need to track the set of class IDs used, to enforce limits. */
     private uniqueClassIds: UniqueClassIds = new UniqueClassIds(),
+    private writtenPublicDataSlots: Set<string> = new Set(),
   ) {
     this.sideEffectCounter = startSideEffectCounter;
-    this.avmCircuitHints = AvmExecutionHints.empty();
   }
 
   public fork() {
@@ -141,6 +99,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
         this.previousSideEffectArrayLengths.publicLogs + this.publicLogs.length,
       ),
       this.uniqueClassIds.fork(),
+      new Set(this.writtenPublicDataSlots),
     );
   }
 
@@ -153,7 +112,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     forkedTrace.alreadyMergedIntoParent = true;
 
     this.sideEffectCounter = forkedTrace.sideEffectCounter;
-    this.enqueuedCalls.push(...forkedTrace.enqueuedCalls);
+    this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
 
     if (!reverted) {
       this.publicDataWrites.push(...forkedTrace.publicDataWrites);
@@ -161,22 +120,12 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
       this.nullifiers.push(...forkedTrace.nullifiers);
       this.l2ToL1Messages.push(...forkedTrace.l2ToL1Messages);
       this.publicLogs.push(...forkedTrace.publicLogs);
+      this.userPublicDataWritesLength += forkedTrace.userPublicDataWritesLength;
+      this.protocolPublicDataWritesLength += forkedTrace.protocolPublicDataWritesLength;
+      for (const slot of forkedTrace.writtenPublicDataSlots) {
+        this.writtenPublicDataSlots.add(slot);
+      }
     }
-    this.mergeHints(forkedTrace);
-  }
-
-  private mergeHints(forkedTrace: this) {
-    this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
-    this.avmCircuitHints.enqueuedCalls.push(...forkedTrace.avmCircuitHints.enqueuedCalls);
-    this.avmCircuitHints.contractInstances.push(...forkedTrace.avmCircuitHints.contractInstances);
-    this.avmCircuitHints.contractClasses.push(...forkedTrace.avmCircuitHints.contractClasses);
-    this.avmCircuitHints.publicDataReads.push(...forkedTrace.avmCircuitHints.publicDataReads);
-    this.avmCircuitHints.publicDataWrites.push(...forkedTrace.avmCircuitHints.publicDataWrites);
-    this.avmCircuitHints.nullifierReads.push(...forkedTrace.avmCircuitHints.nullifierReads);
-    this.avmCircuitHints.nullifierWrites.push(...forkedTrace.avmCircuitHints.nullifierWrites);
-    this.avmCircuitHints.noteHashReads.push(...forkedTrace.avmCircuitHints.noteHashReads);
-    this.avmCircuitHints.noteHashWrites.push(...forkedTrace.avmCircuitHints.noteHashWrites);
-    this.avmCircuitHints.l1ToL2MessageReads.push(...forkedTrace.avmCircuitHints.l1ToL2MessageReads);
   }
 
   public getCounter() {
@@ -191,148 +140,85 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     return this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length;
   }
 
-  public tracePublicStorageRead(
-    contractAddress: AztecAddress,
-    slot: Fr,
-    value: Fr,
-    leafPreimage: PublicDataTreeLeafPreimage = PublicDataTreeLeafPreimage.empty(),
-    leafIndex: Fr = Fr.zero(),
-    path: Fr[] = emptyPublicDataPath(),
-  ) {
-    this.avmCircuitHints.publicDataReads.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
-    this.log.trace(
-      `Tracing storage read (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter})`,
-    );
-    this.incrementSideEffectCounter();
-  }
-
   public async tracePublicStorageWrite(
     contractAddress: AztecAddress,
     slot: Fr,
     value: Fr,
     protocolWrite: boolean,
-    lowLeafPreimage: PublicDataTreeLeafPreimage = PublicDataTreeLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyPublicDataPath(),
-    newLeafPreimage: PublicDataTreeLeafPreimage = PublicDataTreeLeafPreimage.empty(),
-    insertionPath: Fr[] = emptyPublicDataPath(),
   ): Promise<void> {
-    if (protocolWrite) {
-      if (
-        this.protocolPublicDataWritesLength + this.previousSideEffectArrayLengths.protocolPublicDataWrites >=
-        PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
-      ) {
-        throw new SideEffectLimitReachedError(
-          'protocol public data (contract storage) write',
-          PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        );
-      }
-      this.protocolPublicDataWritesLength++;
-    } else {
-      if (
-        this.userPublicDataWritesLength + this.previousSideEffectArrayLengths.publicDataWrites >=
-        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
-      ) {
-        throw new SideEffectLimitReachedError(
-          'public data (contract storage) write',
-          MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        );
+    // Only increment counts if the storage slot has not been written to before.
+    if (this.isStorageCold(contractAddress, slot)) {
+      if (protocolWrite) {
+        if (
+          this.protocolPublicDataWritesLength + this.previousSideEffectArrayLengths.protocolPublicDataWrites >=
+          PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+        ) {
+          throw new SideEffectLimitReachedError(
+            'protocol public data (contract storage) write',
+            PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+          );
+        }
+        this.protocolPublicDataWritesLength++;
+      } else {
+        if (
+          this.userPublicDataWritesLength + this.previousSideEffectArrayLengths.publicDataWrites >=
+          MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+        ) {
+          throw new SideEffectLimitReachedError(
+            'public data (contract storage) write',
+            MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+          );
+        }
+        this.userPublicDataWritesLength++;
       }
-      this.userPublicDataWritesLength++;
     }
 
     const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
     this.publicDataWrites.push(new PublicDataUpdateRequest(leafSlot, value, this.sideEffectCounter));
 
-    // New hinting
-    const readHint = new AvmPublicDataReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.publicDataWrites.push(
-      new AvmPublicDataWriteTreeHint(readHint, newLeafPreimage, insertionPath),
-    );
-
     this.log.trace(
       `Traced public data write (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter}, isProtocol:${protocolWrite})`,
     );
     this.incrementSideEffectCounter();
+    this.writtenPublicDataSlots.add(this.computePublicDataSlotKey(contractAddress, slot));
   }
 
-  // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceNoteHashCheck(
-    _contractAddress: AztecAddress,
-    noteHash: Fr,
-    leafIndex: Fr,
-    _exists: boolean,
-    path: Fr[] = emptyNoteHashPath(),
-  ) {
-    // New Hinting
-    this.avmCircuitHints.noteHashReads.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
-    // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
-    this.log.trace(`Tracing note hash check (counter=${this.sideEffectCounter})`);
+  private computePublicDataSlotKey(contractAddress: AztecAddress, slot: Fr): string {
+    return `${contractAddress.toString()}:${slot.toString()}`;
   }
 
-  public traceNewNoteHash(noteHash: Fr, leafIndex: Fr = Fr.zero(), path: Fr[] = emptyNoteHashPath()) {
+  public isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean {
+    return !this.writtenPublicDataSlots.has(this.computePublicDataSlotKey(contractAddress, slot));
+  }
+
+  public traceNewNoteHash(noteHash: Fr) {
     if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
       throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
     }
 
     this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
-    this.avmCircuitHints.noteHashWrites.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     this.log.trace(`Tracing new note hash (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
 
-  public traceNullifierCheck(
-    _siloedNullifier: Fr,
-    _exists: boolean,
-    lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyNullifierPath(),
-  ) {
-    this.avmCircuitHints.nullifierReads.push(new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath));
-    this.log.trace(`Tracing nullifier check (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public traceNewNullifier(
-    siloedNullifier: Fr,
-    lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyNullifierPath(),
-    insertionPath: Fr[] = emptyNullifierPath(),
-  ) {
+  public traceNewNullifier(siloedNullifier: Fr) {
     if (this.nullifiers.length + this.previousSideEffectArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
       throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
     }
 
     this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
 
-    const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.nullifierWrites.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
     this.log.trace(`Tracing new nullifier (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
 
-  // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceL1ToL2MessageCheck(
-    _contractAddress: AztecAddress,
-    msgHash: Fr,
-    msgLeafIndex: Fr,
-    _exists: boolean,
-    path: Fr[] = emptyL1ToL2MessagePath(),
-  ) {
-    this.avmCircuitHints.l1ToL2MessageReads.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
-    this.log.trace(`Tracing l1 to l2 message check (counter=${this.sideEffectCounter})`);
-  }
-
   public traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr) {
     if (this.l2ToL1Messages.length + this.previousSideEffectArrayLengths.l2ToL1Msgs >= MAX_L2_TO_L1_MSGS_PER_TX) {
       throw new SideEffectLimitReachedError('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
     }
 
     const recipientAddress = EthAddress.fromField(recipient);
-    this.l2ToL1Messages.push(
-      new L2ToL1Message(recipientAddress, content, this.sideEffectCounter).scope(contractAddress),
-    );
+    this.l2ToL1Messages.push(new L2ToL1Message(recipientAddress, content).scope(contractAddress));
     this.log.trace(`Tracing new l2 to l1 message (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
@@ -342,46 +228,18 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
       throw new SideEffectLimitReachedError('public log', MAX_PUBLIC_LOGS_PER_TX);
     }
 
-    if (log.length > PUBLIC_LOG_DATA_SIZE_IN_FIELDS) {
-      throw new Error(`Emitted public log is too large, max: ${PUBLIC_LOG_DATA_SIZE_IN_FIELDS}, passed: ${log.length}`);
+    if (log.length > PUBLIC_LOG_SIZE_IN_FIELDS) {
+      throw new Error(`Emitted public log is too large, max: ${PUBLIC_LOG_SIZE_IN_FIELDS}, passed: ${log.length}`);
     }
-    const publicLog = new PublicLog(contractAddress, padArrayEnd(log, Fr.ZERO, PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
+    const publicLog = new PublicLog(contractAddress, padArrayEnd(log, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS), log.length);
     this.publicLogs.push(publicLog);
     this.log.trace(`Tracing new public log (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
 
-  public traceGetContractInstance(
-    contractAddress: AztecAddress,
-    exists: boolean,
-    instance: SerializableContractInstance = SerializableContractInstance.default(),
-    updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
-    updatePreimage: Fr[] = [],
-  ) {
-    this.avmCircuitHints.contractInstances.push(
-      new AvmContractInstanceHint(
-        contractAddress,
-        exists,
-        instance.salt,
-        instance.deployer,
-        instance.currentContractClassId,
-        instance.originalContractClassId,
-        instance.initializationHash,
-        instance.publicKeys,
-        updateMembershipHint,
-        updatePreimage,
-      ),
-    );
-    this.log.trace(`Tracing contract instance retrieval (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public traceGetContractClass(contractClassId: Fr, exists: boolean, contractClass?: ContractClassWithCommitment) {
-    if (!exists) {
-      this.avmCircuitHints.contractClasses.push(
-        new AvmContractClassHint(contractClassId, exists, Fr.zero(), Fr.zero(), Fr.zero(), Buffer.alloc(0)),
-      );
-    } else if (!this.uniqueClassIds.has(contractClassId.toString())) {
+  public traceGetContractClass(contractClassId: Fr, exists: boolean) {
+    // We limit the number of unique contract class IDs due to hashing and the trace length limit.
+    if (exists && !this.uniqueClassIds.has(contractClassId.toString())) {
       if (this.uniqueClassIds.size() >= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS) {
         this.log.debug(`Bytecode retrieval failure for contract class ID ${contractClassId} (limit reached)`);
         throw new SideEffectLimitReachedError(
@@ -389,43 +247,14 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
           MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
         );
       }
-
+      this.log.trace(`Adding contract class ID ${contractClassId} (counter=${this.sideEffectCounter})`);
       this.uniqueClassIds.add(contractClassId.toString());
-      this.avmCircuitHints.contractClasses.push(
-        new AvmContractClassHint(
-          contractClassId,
-          exists,
-          contractClass!.artifactHash,
-          contractClass!.privateFunctionsRoot,
-          contractClass!.publicBytecodeCommitment,
-          contractClass!.packedBytecode,
-        ),
-      );
-
       this.incrementSideEffectCounter();
     }
   }
 
-  /**
-   * Trace an enqueued call.
-   * Accept some results from a finished call's trace into this one.
-   */
-  public traceEnqueuedCall(
-    /** The call request from private that enqueued this call. */
-    publicCallRequest: PublicCallRequest,
-    /** The call's calldata */
-    calldata: Fr[],
-    /** Did the call revert? */
-    _reverted: boolean,
-  ) {
-    // TODO(4805): check if some threshold is reached for max enqueued or nested calls (to unique contracts?)
-    this.enqueuedCalls.push(publicCallRequest);
-    this.avmCircuitHints.enqueuedCalls.push(new AvmEnqueuedCallHint(publicCallRequest.contractAddress, calldata));
-  }
-
   public getSideEffects(): SideEffects {
     return {
-      enqueuedCalls: this.enqueuedCalls,
       publicDataWrites: this.publicDataWrites,
       noteHashes: this.noteHashes,
       nullifiers: this.nullifiers,
@@ -433,84 +262,4 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
       publicLogs: this.publicLogs,
     };
   }
-
-  public toAvmCircuitPublicInputs(
-    /** Globals. */
-    globalVariables: GlobalVariables,
-    /** Start tree snapshots. */
-    startTreeSnapshots: TreeSnapshots,
-    /** Gas used at start of TX. */
-    startGasUsed: Gas,
-    /** How much gas was available for this public execution. */
-    gasLimits: GasSettings,
-    /** Address of the fee payer. */
-    feePayer: AztecAddress,
-    /** Call requests for setup phase. */
-    publicSetupCallRequests: PublicCallRequest[],
-    /** Call requests for app logic phase. */
-    publicAppLogicCallRequests: PublicCallRequest[],
-    /** Call request for teardown phase. */
-    publicTeardownCallRequest: PublicCallRequest,
-    /** End tree snapshots. */
-    endTreeSnapshots: TreeSnapshots,
-    /**
-     * Gas used by the whole transaction, assuming entire teardown limit is used.
-     * This is the gas used when computing transaction fee.
-     */
-    endGasUsed: Gas,
-    /** Transaction fee. */
-    transactionFee: Fr,
-    /** The call's results */
-    reverted: boolean,
-  ): AvmCircuitPublicInputs {
-    return new AvmCircuitPublicInputs(
-      globalVariables,
-      startTreeSnapshots,
-      startGasUsed,
-      gasLimits,
-      feePayer,
-      padArrayEnd(publicSetupCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX),
-      padArrayEnd(publicAppLogicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX),
-      publicTeardownCallRequest,
-      /*previousNonRevertibleAccumulatedDataArrayLengths=*/ PrivateToAvmAccumulatedDataArrayLengths.empty(),
-      /*previousRevertibleAccumulatedDataArrayLengths=*/ PrivateToAvmAccumulatedDataArrayLengths.empty(),
-      /*previousNonRevertibleAccumulatedDataArray=*/ PrivateToAvmAccumulatedData.empty(),
-      /*previousRevertibleAccumulatedDataArray=*/ PrivateToAvmAccumulatedData.empty(),
-      endTreeSnapshots,
-      endGasUsed,
-      /*accumulatedData=*/ this.getAvmAccumulatedData(),
-      transactionFee,
-      reverted,
-    );
-  }
-
-  public getPublicLogs() {
-    return this.publicLogs;
-  }
-
-  public getAvmCircuitHints() {
-    return this.avmCircuitHints;
-  }
-
-  private getAvmAccumulatedData() {
-    return new AvmAccumulatedData(
-      padArrayEnd(
-        this.noteHashes.map(n => n.value),
-        Fr.zero(),
-        MAX_NOTE_HASHES_PER_TX,
-      ),
-      padArrayEnd(
-        this.nullifiers.map(n => n.value),
-        Fr.zero(),
-        MAX_NULLIFIERS_PER_TX,
-      ),
-      padArrayEnd(this.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX),
-      padArrayEnd(this.publicLogs, PublicLog.empty(), MAX_PUBLIC_LOGS_PER_TX),
-      padArrayEnd(
-        this.publicDataWrites.map(w => new PublicDataWrite(w.leafSlot, w.newValue)),
-        PublicDataWrite.empty(),
-        MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-      ),
-    );
-  }
 }

package/src/public/side_effect_trace_interface.ts

@@ -1,76 +1,22 @@
 import type { Fr } from '@aztec/foundation/fields';
-import type { AvmPublicDataReadTreeHint } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractClassWithCommitment, SerializableContractInstance } from '@aztec/stdlib/contract';
-import type { PublicCallRequest } from '@aztec/stdlib/kernel';
-import type { PublicLog } from '@aztec/stdlib/logs';
-import type { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
 
 export interface PublicSideEffectTraceInterface {
   fork(): PublicSideEffectTraceInterface;
   merge(nestedTrace: PublicSideEffectTraceInterface, reverted?: boolean): void;
   getCounter(): number;
   // all "trace*" functions can throw SideEffectLimitReachedError
-  tracePublicStorageRead(
-    contractAddress: AztecAddress,
-    slot: Fr,
-    value: Fr,
-    leafPreimage?: PublicDataTreeLeafPreimage,
-    leafIndex?: Fr,
-    path?: Fr[],
-  ): void;
   tracePublicStorageWrite(
     contractAddress: AztecAddress,
     slot: Fr, // This is the storage slot not the computed leaf slot
     value: Fr,
     protocolWrite: boolean,
-    lowLeafPreimage?: PublicDataTreeLeafPreimage,
-    lowLeafIndex?: Fr,
-    lowLeafPath?: Fr[],
-    newLeafPreimage?: PublicDataTreeLeafPreimage,
-    insertionPath?: Fr[],
   ): Promise<void>;
-  traceNoteHashCheck(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr, exists: boolean, path?: Fr[]): void;
-  traceNewNoteHash(uniqueNoteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
+  isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean;
+  traceNewNoteHash(uniqueNoteHash: Fr): void;
   getNoteHashCount(): number;
-  traceNullifierCheck(
-    siloedNullifier: Fr,
-    exists: boolean,
-    lowLeafPreimage?: NullifierLeafPreimage,
-    lowLeafIndex?: Fr,
-    lowLeafPath?: Fr[],
-  ): void;
-  traceNewNullifier(
-    siloedNullifier: Fr,
-    lowLeafPreimage?: NullifierLeafPreimage,
-    lowLeafIndex?: Fr,
-    lowLeafPath?: Fr[],
-    insertionPath?: Fr[],
-  ): void;
-  traceL1ToL2MessageCheck(
-    contractAddress: AztecAddress,
-    msgHash: Fr,
-    msgLeafIndex: Fr,
-    exists: boolean,
-    path?: Fr[],
-  ): void;
+  traceNewNullifier(siloedNullifier: Fr): void;
   traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr): void;
   tracePublicLog(contractAddress: AztecAddress, log: Fr[]): void;
-  traceGetContractInstance(
-    contractAddress: AztecAddress,
-    exists: boolean,
-    instance?: SerializableContractInstance,
-    updateMembershipHint?: AvmPublicDataReadTreeHint,
-    updatePreimage?: Fr[],
-  ): void;
-  traceGetContractClass(contractClassId: Fr, exists: boolean, contractClass?: ContractClassWithCommitment): void;
-  traceEnqueuedCall(
-    /** The call request from private that enqueued this call. */
-    publicCallRequest: PublicCallRequest,
-    /** The call's calldata */
-    calldata: Fr[],
-    /** Did the call revert? */
-    reverted: boolean,
-  ): void;
-  getPublicLogs(): PublicLog[];
+  traceGetContractClass(contractClassId: Fr, exists: boolean): void;
 }

package/src/public/state_manager/index.ts

@@ -0,0 +1 @@
+export * from './state_manager.js';

package/src/public/{avm/journal → state_manager}/nullifiers.ts

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 
-import type { WorldStateDB } from '../../public_db_sources.js';
+import type { PublicTreesDB } from '../public_db_sources.js';
 
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
@@ -10,7 +10,7 @@ import type { WorldStateDB } from '../../public_db_sources.js';
 export class NullifierManager {
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    private readonly hostNullifiers: WorldStateDB,
+    private readonly hostNullifiers: PublicTreesDB,
     /** Cache of siloed nullifiers. */
     private cache: Set<bigint> = new Set(),
     /** Parent nullifier manager to fall back on */
@@ -64,8 +64,8 @@ export class NullifierManager {
       //  `${MerkleTreeId[MerkleTreeId.NULLIFIER_TREE]} low leaf index should always be found (even if target leaf does not exist)`,
       //);
       //existsInTree = leafOrLowLeafIndex.alreadyPresent;
-      const leafIndex = await this.hostNullifiers.getNullifierIndex(siloedNullifier);
-      existsInTree = leafIndex !== undefined;
+      const exists = await this.hostNullifiers.checkNullifierExists(siloedNullifier);
+      existsInTree = exists;
     }
     const exists = cacheHit || existsInTree;
     return Promise.resolve({ exists, cacheHit });

package/src/public/{avm/journal → state_manager}/public_storage.ts

@@ -1,7 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { PublicStateDB } from '../../../common/db_interfaces.js';
+import type { PublicStateDBInterface } from '../db_interfaces.js';
 
 type PublicStorageReadResult = {
   value: Fr;
@@ -19,7 +19,7 @@ export class PublicStorage {
 
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
-    private readonly hostPublicStorage: PublicStateDB,
+    private readonly hostPublicStorage: PublicStateDBInterface,
     /** Parent's storage. Checked on this' cache-miss. */
     private readonly parent?: PublicStorage,
   ) {