@aztec/simulator 0.52.0 → 0.54.0

package/src/public/hints_builder.ts

@@ -1,33 +1,48 @@
 import { type IndexedTreeId, MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
   type MAX_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  type MAX_PUBLIC_DATA_HINTS,
   type MAX_PUBLIC_DATA_READS_PER_TX,
   type MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
+  NOTE_HASH_TREE_HEIGHT,
   NULLIFIER_TREE_HEIGHT,
   type Nullifier,
   PUBLIC_DATA_TREE_HEIGHT,
-  type PublicDataHint,
   type PublicDataRead,
   type PublicDataTreeLeafPreimage,
   type PublicDataUpdateRequest,
   type ScopedReadRequest,
+  type TreeLeafReadRequest,
+  TreeLeafReadRequestHint,
   buildNullifierNonExistentReadRequestHints,
   buildPublicDataHint,
   buildPublicDataHints,
-  buildPublicDataReadRequestHints,
   buildSiloedNullifierReadRequestHints,
 } from '@aztec/circuits.js';
+import { makeTuple } from '@aztec/foundation/array';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
 export class HintsBuilder {
   constructor(private db: MerkleTreeOperations) {}
 
+  async getNoteHashReadRequestsHints(
+    readRequests: Tuple<TreeLeafReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
+  ) {
+    return await this.getTreeLeafReadRequestsHints(
+      readRequests,
+      MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+      NOTE_HASH_TREE_HEIGHT,
+      MerkleTreeId.NOTE_HASH_TREE,
+    );
+  }
+
   async getNullifierReadRequestHints(
     nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
     pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
@@ -50,6 +65,17 @@ export class HintsBuilder {
     return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
   }
 
+  async getL1ToL2MsgReadRequestsHints(
+    readRequests: Tuple<TreeLeafReadRequest, typeof MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX>,
+  ) {
+    return await this.getTreeLeafReadRequestsHints(
+      readRequests,
+      MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX,
+      L1_TO_L2_MSG_TREE_HEIGHT,
+      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+    );
+  }
+
   getPublicDataHints(
     publicDataReads: Tuple<PublicDataRead, typeof MAX_PUBLIC_DATA_READS_PER_TX>,
     publicDataUpdateRequests: Tuple<PublicDataUpdateRequest, typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX>,
@@ -62,14 +88,6 @@ export class HintsBuilder {
     return buildPublicDataHint(this, slot);
   }
 
-  getPublicDataReadRequestHints(
-    publicDataReads: Tuple<PublicDataRead, typeof MAX_PUBLIC_DATA_READS_PER_TX>,
-    publicDataUpdateRequests: Tuple<PublicDataUpdateRequest, typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX>,
-    publicDataHints: Tuple<PublicDataHint, typeof MAX_PUBLIC_DATA_HINTS>,
-  ) {
-    return buildPublicDataReadRequestHints(publicDataReads, publicDataUpdateRequests, publicDataHints);
-  }
-
   async getNullifierMembershipWitness(nullifier: Fr) {
     const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
     if (index === undefined) {
@@ -120,8 +138,8 @@ export class HintsBuilder {
     treeHeight: TREE_HEIGHT,
     index: bigint,
   ) {
-    const siblingPath = await this.db.getSiblingPath(treeId, index);
-    const membershipWitness = new MembershipWitness<TREE_HEIGHT>(treeHeight, index, siblingPath.toTuple());
+    const siblingPath = await this.db.getSiblingPath<TREE_HEIGHT>(treeId, index);
+    const membershipWitness = new MembershipWitness(treeHeight, index, siblingPath.toTuple());
 
     const leafPreimage = await this.db.getLeafPreimage(treeId, index);
     if (!leafPreimage) {
@@ -130,4 +148,21 @@ export class HintsBuilder {
 
     return { membershipWitness, leafPreimage };
   }
+
+  private async getTreeLeafReadRequestsHints<N extends number, TREE_HEIGHT extends number>(
+    readRequests: Tuple<TreeLeafReadRequest, N>,
+    size: N,
+    treeHeight: TREE_HEIGHT,
+    treeId: MerkleTreeId,
+  ): Promise<Tuple<TreeLeafReadRequestHint<TREE_HEIGHT>, N>> {
+    const hints = makeTuple(size, () => TreeLeafReadRequestHint.empty(treeHeight));
+    for (let i = 0; i < readRequests.length; i++) {
+      const request = readRequests[i];
+      if (!request.isEmpty()) {
+        const siblingPath = await this.db.getSiblingPath<typeof treeHeight>(treeId, request.leafIndex.toBigInt());
+        hints[i] = new TreeLeafReadRequestHint(treeHeight, siblingPath.toTuple());
+      }
+    }
+    return hints;
+  }
 }

package/src/public/public_db_sources.ts

@@ -308,6 +308,17 @@ export class WorldStateDB implements CommitmentsDB {
     return index;
   }
 
+  public async getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined> {
+    const timer = new Timer();
+    const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+    this.log.debug(`[DB] Fetched commitment leaf value`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-commitment-leaf-value',
+    } satisfies PublicDBAccessStats);
+    return leafValue;
+  }
+
   public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
     const timer = new Timer();
     const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());

package/src/public/side_effect_trace.ts

@@ -16,6 +16,7 @@ import {
   Nullifier,
   type PublicCallRequest,
   ReadRequest,
+  TreeLeafReadRequest,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -38,14 +39,14 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   private contractStorageReads: ContractStorageRead[] = [];
   private contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
 
-  private noteHashReadRequests: ReadRequest[] = [];
+  private noteHashReadRequests: TreeLeafReadRequest[] = [];
   private noteHashes: NoteHash[] = [];
 
   private nullifierReadRequests: ReadRequest[] = [];
   private nullifierNonExistentReadRequests: ReadRequest[] = [];
   private nullifiers: Nullifier[] = [];
 
-  private l1ToL2MsgReadRequests: ReadRequest[] = [];
+  private l1ToL2MsgReadRequests: TreeLeafReadRequest[] = [];
   private newL2ToL1Messages: L2ToL1Message[] = [];
 
   private unencryptedLogs: UnencryptedL2Log[] = [];
@@ -104,17 +105,16 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.incrementSideEffectCounter();
   }
 
-  public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, _leafIndex: Fr, exists: boolean) {
+  // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
+  public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
     // TODO(4805): check if some threshold is reached for max note hash checks
     // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
     // TODO(dbanks12): leafIndex is unused for now but later must be used by kernel to constrain that the kernel
     // is in fact checking the leaf indicated by the user
-    this.noteHashReadRequests.push(new ReadRequest(noteHash, this.sideEffectCounter));
+    this.noteHashReadRequests.push(new TreeLeafReadRequest(noteHash, leafIndex));
     this.avmCircuitHints.noteHashExists.items.push(
-      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
+      new AvmKeyValueHint(/*key=*/ new Fr(leafIndex), /*value=*/ exists ? Fr.ONE : Fr.ZERO),
     );
-    this.logger.debug(`NOTE_HASH_CHECK cnt: ${this.sideEffectCounter}`);
-    this.incrementSideEffectCounter();
   }
 
   public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
@@ -154,17 +154,16 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     this.incrementSideEffectCounter();
   }
 
-  public traceL1ToL2MessageCheck(_contractAddress: Fr, msgHash: Fr, _msgLeafIndex: Fr, exists: boolean) {
+  // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
+  public traceL1ToL2MessageCheck(_contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean) {
     // TODO(4805): check if some threshold is reached for max message reads
     // NOTE: contractAddress is unused but will be important when an AVM circuit processes an entire enqueued call
     // TODO(dbanks12): leafIndex is unused for now but later must be used by kernel to constrain that the kernel
     // is in fact checking the leaf indicated by the user
-    this.l1ToL2MsgReadRequests.push(new ReadRequest(msgHash, this.sideEffectCounter));
+    this.l1ToL2MsgReadRequests.push(new TreeLeafReadRequest(msgHash, msgLeafIndex));
     this.avmCircuitHints.l1ToL2MessageExists.items.push(
-      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
+      new AvmKeyValueHint(/*key=*/ new Fr(msgLeafIndex), /*value=*/ exists ? Fr.ONE : Fr.ZERO),
     );
-    this.logger.debug(`L1_TO_L2_MSG_CHECK cnt: ${this.sideEffectCounter}`);
-    this.incrementSideEffectCounter();
   }
 
   public traceNewL2ToL1Message(recipient: Fr, content: Fr) {

package/src/public/tail_phase_manager.ts

@@ -77,6 +77,10 @@ export class TailPhaseManager extends AbstractPhaseManager {
 
     const { validationRequests, endNonRevertibleData: nonRevertibleData, end: revertibleData } = previousOutput;
 
+    const noteHashReadRequestHints = await this.hintsBuilder.getNoteHashReadRequestsHints(
+      validationRequests.noteHashReadRequests,
+    );
+
     const pendingNullifiers = mergeAccumulatedData(
       nonRevertibleData.nullifiers,
       revertibleData.nullifiers,
@@ -93,6 +97,10 @@ export class TailPhaseManager extends AbstractPhaseManager {
       pendingNullifiers,
     );
 
+    const l1ToL2MsgReadRequestHints = await this.hintsBuilder.getL1ToL2MsgReadRequestsHints(
+      validationRequests.l1ToL2MsgReadRequests,
+    );
+
     const pendingPublicDataWrites = mergeAccumulatedData(
       nonRevertibleData.publicDataUpdateRequests,
       revertibleData.publicDataUpdateRequests,
@@ -104,20 +112,15 @@ export class TailPhaseManager extends AbstractPhaseManager {
       pendingPublicDataWrites,
     );
 
-    const publicDataReadRequestHints = this.hintsBuilder.getPublicDataReadRequestHints(
-      validationRequests.publicDataReads,
-      pendingPublicDataWrites,
-      publicDataHints,
-    );
-
     const currentState = await this.db.getStateReference();
 
     return new PublicKernelTailCircuitPrivateInputs(
       previousKernel,
+      noteHashReadRequestHints,
       nullifierReadRequestHints,
       nullifierNonExistentReadRequestHints,
+      l1ToL2MsgReadRequestHints,
       publicDataHints,
-      publicDataReadRequestHints,
       currentState.partial,
     );
   }