@aztec/simulator 0.84.0 → 0.85.0

package/src/private/execution_data_provider.ts

@@ -1,3 +1,4 @@
+import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr, Point } from '@aztec/foundation/fields';
 import type {
   EventSelector,
@@ -14,8 +15,8 @@ import type { NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
 
-import type { CommitmentsDBInterface } from '../common/db_interfaces.js';
 import type { NoteData } from './acvm/index.js';
+import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
 
 /**
  * Error thrown when a contract is not found in the database.
@@ -38,7 +39,7 @@ export class ContractClassNotFoundError extends Error {
 /**
  * The interface for the data layer required to perform private and utility execution.
  */
-export interface ExecutionDataProvider extends CommitmentsDBInterface {
+export interface ExecutionDataProvider {
   /**
    * Returns a contract instance associated with an address, if available.
    * @param address - Address.
@@ -117,6 +118,40 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
    */
   getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
 
+  /**
+   * Gets the index of a nullifier in the nullifier tree.
+   * @param nullifier - The nullifier.
+   * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
+   */
+  getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
+
+  /**
+   * Returns a nullifier membership witness for the given nullifier or undefined if not found.
+   * REFACTOR: Same as getL1ToL2MembershipWitness, can be combined with aztec-node method that does almost the same thing.
+   * @param nullifier - Nullifier we're looking for.
+   */
+  getNullifierMembershipWitnessAtLatestBlock(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+
+  /**
+   * Fetches a message from the db, given its key.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @param messageHash - Hash of the message.
+   * @param secret - Secret used to compute a nullifier.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
+   */
+  getL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
+
+  /**
+   * @param leafIndex the leaf to look up
+   * @returns The l1 to l2 leaf message hash or undefined if not found.
+   */
+  getL1ToL2MessageHash(leafIndex: bigint): Promise<Fr | undefined>;
+
   /**
    * Retrieve the databases view of the Block Header object.
    * This structure is fed into the circuits simulator and is used to prove against certain historical roots.
@@ -259,10 +294,17 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
     content: Fr[],
     noteHash: Fr,
     nullifier: Fr,
-    txHash: Fr,
+    txHash: TxHash,
     recipient: AztecAddress,
   ): Promise<void>;
 
+  /**
+   * Gets note hash in the note hash tree at the given leaf index.
+   * @param leafIndex - the leaf to look up.
+   * @returns - The note hash at that index. Undefined if leaf index is not found.
+   */
+  getNoteHash(leafIndex: bigint): Promise<Fr | undefined>;
+
   /**
    * Searches for a log with the corresponding `tag` and returns it along with contextual transaction information.
    * Returns null if no such log exists, and throws if more than one exists.
@@ -329,16 +371,18 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
    * @param contractAddress - The address of the contract that emitted the log.
    * @param recipient - The address of the recipient.
    * @param eventSelector - The event selector of the event.
-   * @param logContent - The content of the private event log.
+   * @param msgContent - The content of the private event message.
    * @param txHash - The hash of the transaction that emitted the log.
    * @param logIndexInTx - The index of the log within the transaction.
+   * @param txIndexInBlock - The index of the transaction in which the log was emitted in the block.
    */
   storePrivateEventLog(
     contractAddress: AztecAddress,
     recipient: AztecAddress,
     eventSelector: EventSelector,
-    logContent: Fr[],
+    msgContent: Fr[],
     txHash: TxHash,
     logIndexInTx: number,
+    txIndexInBlock: number,
   ): Promise<void>;
 }

package/src/private/index.ts

@@ -13,3 +13,4 @@ export { extractCallStack } from './acvm/acvm.js';
 export { type NoteData, TypedOracle } from './acvm/oracle/typed_oracle.js';
 export { Oracle } from './acvm/oracle/oracle.js';
 export { HashedValuesCache } from './hashed_values_cache.js';
+export { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';

package/src/private/simulator.ts

@@ -115,7 +115,7 @@ export class AcirSimulator {
     }
   }
 
-  // docs:start:execute_unconstrained_function
+  // docs:start:execute_utility_function
   /**
    * Runs a utility function.
    * @param call - The function call to execute.
@@ -163,5 +163,5 @@ export class AcirSimulator {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
   }
-  // docs:end:execute_unconstrained_function
+  // docs:end:execute_utility_function
 }

package/src/private/utility_execution_oracle.ts

@@ -256,10 +256,6 @@ export class UtilityExecutionOracle extends TypedOracle {
   }
 
   public override debugLog(message: string, fields: Fr[]): void {
-    // TODO(#10558) Remove this check once the debug log is fixed
-    if (message.startsWith('Context.note_hashes, after pushing new note hash:')) {
-      return;
-    }
     this.log.verbose(`${applyStringFormatting(message, fields)}`, { module: `${this.log.module}:debug_log` });
   }
 
@@ -291,7 +287,7 @@ export class UtilityExecutionOracle extends TypedOracle {
     content: Fr[],
     noteHash: Fr,
     nullifier: Fr,
-    txHash: Fr,
+    txHash: TxHash,
     recipient: AztecAddress,
   ) {
     // TODO(#10727): allow other contracts to deliver notes
@@ -370,17 +366,19 @@ export class UtilityExecutionOracle extends TypedOracle {
     contractAddress: AztecAddress,
     recipient: AztecAddress,
     eventSelector: EventSelector,
-    logContent: Fr[],
+    msgContent: Fr[],
     txHash: TxHash,
     logIndexInTx: number,
+    txIndexInBlock: number,
   ): Promise<void> {
     return this.executionDataProvider.storePrivateEventLog(
       contractAddress,
       recipient,
       eventSelector,
-      logContent,
+      msgContent,
       txHash,
       logIndexInTx,
+      txIndexInBlock,
     );
   }
 }

package/src/public/avm/fixtures/base_avm_simulation_tester.ts

@@ -44,7 +44,7 @@ export abstract class BaseAvmSimulationTester {
     const leafSlot = await computePublicDataTreeLeafSlot(address, slot);
     // get existing preimage
     const publicDataWrite = new PublicDataWrite(leafSlot, value);
-    await this.merkleTrees.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()], 0);
+    await this.merkleTrees.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
   }
 
   /**
@@ -98,6 +98,6 @@ export abstract class BaseAvmSimulationTester {
       AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
       contractAddress.toField(),
     );
-    await this.merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
+    await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()]);
   }
 }

package/src/public/avm/test_utils.ts

@@ -38,8 +38,8 @@ export function mockNoteHashExists(worldStateDB: PublicTreesDB, _leafIndex: Fr,
   });
 }
 
-export function mockGetNullifierIndex(worldStateDB: PublicTreesDB, leafIndex: Fr, _ignoredValue?: Fr) {
-  (worldStateDB as jest.Mocked<PublicTreesDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+export function mockCheckNullifierExists(worldStateDB: PublicTreesDB, exists: boolean, _ignoredValue?: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).checkNullifierExists.mockResolvedValue(exists);
 }
 
 export function mockL1ToL2MessageExists(

package/src/{common → public}/db_interfaces.ts

@@ -1,11 +1,7 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import type { NullifierMembershipWitness } from '@aztec/stdlib/trees';
-
-import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
 
 /**
  * Database interface for providing access to public state.
@@ -62,47 +58,3 @@ export interface PublicContractsDBInterface {
    */
   getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }
-
-/** Database interface for providing access to note hash tree, l1 to l2 message tree, and nullifier tree. */
-export interface CommitmentsDBInterface {
-  /**
-   * Fetches a message from the db, given its key.
-   * @param contractAddress - Address of a contract by which the message was emitted.
-   * @param messageHash - Hash of the message.
-   * @param secret - Secret used to compute a nullifier.
-   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
-   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
-   */
-  getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
-
-  /**
-   * @param leafIndex the leaf to look up
-   * @returns The l1 to l2 leaf message hash or undefined if not found.
-   */
-  getL1ToL2MessageHash(leafIndex: bigint): Promise<Fr | undefined>;
-
-  /**
-   * Gets note hash in the note hash tree at the given leaf index.
-   * @param leafIndex - the leaf to look up.
-   * @returns - The note hash at that index. Undefined if leaf index is not found.
-   */
-  getNoteHash(leafIndex: bigint): Promise<Fr | undefined>;
-
-  /**
-   * Gets the index of a nullifier in the nullifier tree.
-   * @param nullifier - The nullifier.
-   * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
-   */
-  getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
-
-  /**
-   * Returns a nullifier membership witness for the given nullifier or undefined if not found.
-   * REFACTOR: Same as getL1ToL2MembershipWitness, can be combined with aztec-node method that does almost the same thing.
-   * @param nullifier - Nullifier we're looking for.
-   */
-  getNullifierMembershipWitnessAtLatestBlock(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
-}

package/src/public/hinting_db_sources.ts

@@ -1,17 +1,22 @@
+import { sha256Trunc } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import {
+  AvmAppendLeavesHint,
   AvmBytecodeCommitmentHint,
+  AvmCommitCheckpointHint,
   AvmContractClassHint,
   AvmContractInstanceHint,
+  AvmCreateCheckpointHint,
   type AvmExecutionHints,
   AvmGetLeafPreimageHintNullifierTree,
   AvmGetLeafPreimageHintPublicDataTree,
   AvmGetLeafValueHint,
   AvmGetPreviousValueIndexHint,
   AvmGetSiblingPathHint,
+  AvmRevertCheckpointHint,
   AvmSequentialInsertHintNullifierTree,
   AvmSequentialInsertHintPublicDataTree,
 } from '@aztec/stdlib/avm';
@@ -28,11 +33,12 @@ import {
   PublicDataTreeLeafPreimage,
   type SequentialInsertionResult,
   getTreeName,
+  merkleTreeIds,
 } from '@aztec/stdlib/trees';
 
 import { strict as assert } from 'assert';
 
-import type { PublicContractsDBInterface } from '../common/db_interfaces.js';
+import type { PublicContractsDBInterface } from './db_interfaces.js';
 import { PublicTreesDB } from './public_db_sources.js';
 
 /**
@@ -99,6 +105,13 @@ export class HintingPublicContractsDB implements PublicContractsDBInterface {
  */
 export class HintingPublicTreesDB extends PublicTreesDB {
   private static readonly log: Logger = createLogger('HintingPublicTreesDB');
+  // This stack is only for debugging purposes.
+  // The top of the stack is the current checkpoint id.
+  // We need the stack to be non-empty and use 0 as an arbitrary initial checkpoint id.
+  // This is not necessarily a checkpoint that happened, but whatever tree state we start with.
+  private checkpointStack: number[] = [0];
+  private nextCheckpointId: number = 1;
+  private checkpointActionCounter: number = 0; // yes, a side-effect counter.
 
   constructor(db: PublicTreesDB, private hints: AvmExecutionHints) {
     super(db);
@@ -200,11 +213,8 @@ export class HintingPublicTreesDB extends PublicTreesDB {
     const result = await super.sequentialInsert<TreeHeight, ID>(treeId, leaves);
 
     const afterState = await this.getHintKey(treeId);
-    HintingPublicTreesDB.log.debug(
-      `Evolved tree state (${getTreeName(treeId)}): ${beforeState.root}, ${beforeState.nextAvailableLeafIndex} -> ${
-        afterState.root
-      }, ${afterState.nextAvailableLeafIndex}.`,
-    );
+    HintingPublicTreesDB.log.debug('[sequentialInsert] Evolved tree state.');
+    HintingPublicTreesDB.logTreeChange(beforeState, afterState, treeId);
 
     switch (treeId) {
       case MerkleTreeId.PUBLIC_DATA_TREE:
@@ -255,12 +265,58 @@ export class HintingPublicTreesDB extends PublicTreesDB {
     return result;
   }
 
+  public override async appendLeaves<ID extends MerkleTreeId>(
+    treeId: ID,
+    leaves: MerkleTreeLeafType<ID>[],
+  ): Promise<void> {
+    // Use sequentialInsert for PublicDataTree and NullifierTree.
+    assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+
+    // We need to process each leaf individually because we need the sibling path after insertion, to be able to constraint the insertion.
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13380): This can be changed if the world state appendLeaves returns the sibling paths.
+    for (const leaf of leaves) {
+      await this.appendLeafInternal(treeId, leaf);
+    }
+  }
+
+  public override async createCheckpoint(): Promise<void> {
+    const actionCounter = this.checkpointActionCounter++;
+    const oldCheckpointId = this.getCurrentCheckpointId();
+    const treesStateHash = await this.getTreesStateHash();
+
+    await super.createCheckpoint();
+    this.checkpointStack.push(this.nextCheckpointId++);
+    const newCheckpointId = this.getCurrentCheckpointId();
+
+    this.hints.createCheckpointHints.push(new AvmCreateCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
+
+    HintingPublicTreesDB.log.debug(
+      `[createCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`,
+    );
+  }
+
+  public override async commitCheckpoint(): Promise<void> {
+    const actionCounter = this.checkpointActionCounter++;
+    const oldCheckpointId = this.getCurrentCheckpointId();
+    const treesStateHash = await this.getTreesStateHash();
+
+    await super.commitCheckpoint();
+    this.checkpointStack.pop();
+    const newCheckpointId = this.getCurrentCheckpointId();
+
+    this.hints.commitCheckpointHints.push(new AvmCommitCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
+
+    HintingPublicTreesDB.log.debug(
+      `[commitCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`,
+    );
+  }
+
   public override async revertCheckpoint(): Promise<void> {
-    HintingPublicTreesDB.log.debug('revertCheckpoint not hinted yet!');
-    // TODO(fcarreiro): we probably want to hint on StateReference hash.
-    // WARNING: is this enough? we might actually need the number of the checkpoint or similar...
-    // We will need to keep a stack of checkpoints on the C++ side.
-    const beforeState = {
+    const actionCounter = this.checkpointActionCounter++;
+    const oldCheckpointId = this.getCurrentCheckpointId();
+    const treesStateHash = await this.getTreesStateHash();
+
+    const beforeState: Record<MerkleTreeId, AppendOnlyTreeSnapshot> = {
       [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
       [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
       [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
@@ -269,8 +325,10 @@ export class HintingPublicTreesDB extends PublicTreesDB {
     };
 
     await super.revertCheckpoint();
+    this.checkpointStack.pop();
+    const newCheckpointId = this.getCurrentCheckpointId();
 
-    const afterState = {
+    const afterState: Record<MerkleTreeId, AppendOnlyTreeSnapshot> = {
       [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
       [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
       [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
@@ -278,13 +336,15 @@ export class HintingPublicTreesDB extends PublicTreesDB {
       [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE),
     };
 
-    HintingPublicTreesDB.log.debug('Evolved tree state:');
-    for (const treeId of Object.keys(beforeState)) {
-      const id: MerkleTreeId = treeId as unknown as MerkleTreeId;
-      const treeName = getTreeName(id);
-      HintingPublicTreesDB.log.debug(
-        `${treeName}: ${beforeState[id].root}, ${beforeState[id].nextAvailableLeafIndex} -> ${afterState[id].root}, ${afterState[id].nextAvailableLeafIndex}.`,
-      );
+    this.hints.revertCheckpointHints.push(
+      AvmRevertCheckpointHint.create(actionCounter, oldCheckpointId, newCheckpointId, beforeState, afterState),
+    );
+
+    HintingPublicTreesDB.log.debug(
+      `[revertCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`,
+    );
+    for (const treeId of merkleTreeIds()) {
+      HintingPublicTreesDB.logTreeChange(beforeState[treeId], afterState[treeId], treeId);
     }
   }
 
@@ -293,4 +353,46 @@ export class HintingPublicTreesDB extends PublicTreesDB {
     const treeInfo = await super.getTreeInfo(treeId);
     return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
   }
+
+  private getCurrentCheckpointId(): number {
+    return this.checkpointStack[this.checkpointStack.length - 1];
+  }
+
+  // For logging/debugging purposes.
+  private async getTreesStateHash(): Promise<Fr> {
+    const stateReferenceFields = (await super.getStateReference()).toFields();
+    return Fr.fromBuffer(sha256Trunc(Buffer.concat(stateReferenceFields.map(field => field.toBuffer()))));
+  }
+
+  private static logTreeChange(
+    beforeState: AppendOnlyTreeSnapshot,
+    afterState: AppendOnlyTreeSnapshot,
+    treeId: MerkleTreeId,
+  ) {
+    const treeName = getTreeName(treeId);
+    HintingPublicTreesDB.log.debug(
+      `[${treeName}] Evolved tree state: ${beforeState.root}, ${beforeState.nextAvailableLeafIndex} -> ${afterState.root}, ${afterState.nextAvailableLeafIndex}.`,
+    );
+  }
+
+  private async appendLeafInternal<ID extends MerkleTreeId, N extends number>(
+    treeId: ID,
+    leaf: MerkleTreeLeafType<ID>,
+  ): Promise<SiblingPath<N>> {
+    // Use sequentialInsert for PublicDataTree and NullifierTree.
+    assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+
+    const beforeState = await this.getHintKey(treeId);
+
+    await super.appendLeaves<ID>(treeId, [leaf]);
+
+    const afterState = await this.getHintKey(treeId);
+
+    HintingPublicTreesDB.log.debug('[appendLeaves] Evolved tree state.');
+    HintingPublicTreesDB.logTreeChange(beforeState, afterState, treeId);
+
+    this.hints.appendLeavesHints.push(new AvmAppendLeavesHint(beforeState, afterState, treeId, [leaf as Fr]));
+
+    return await this.getSiblingPath<N>(treeId, BigInt(beforeState.nextAvailableLeafIndex));
+  }
 }

package/src/public/index.ts

@@ -1,4 +1,4 @@
-export * from '../common/db_interfaces.js';
+export * from './db_interfaces.js';
 export * from './public_tx_simulator/index.js';
 export * from './public_db_sources.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';

package/src/public/public_db_sources.ts

@@ -1,3 +1,4 @@
+import { NULLIFIER_SUBTREE_HEIGHT, PUBLIC_DATA_SUBTREE_HEIGHT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -24,10 +25,10 @@ import type {
 } from '@aztec/stdlib/interfaces/server';
 import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
 import type { PublicDBAccessStats } from '@aztec/stdlib/stats';
-import { MerkleTreeId, type PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
+import { MerkleTreeId, NullifierLeaf, PublicDataTreeLeaf, type PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
 import type { BlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
 
-import type { PublicContractsDBInterface, PublicStateDBInterface } from '../common/db_interfaces.js';
+import type { PublicContractsDBInterface, PublicStateDBInterface } from './db_interfaces.js';
 import { TxContractCache } from './tx_contract_cache.js';
 
 /**
@@ -392,7 +393,7 @@ class ForwardMerkleTree implements MerkleTreeWriteOperations {
 export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInterface {
   private logger = createLogger('simulator:public-trees-db');
 
-  constructor(private readonly db: MerkleTreeWriteOperations) {
+  constructor(db: MerkleTreeWriteOperations) {
     super(db);
   }
 
@@ -462,7 +463,7 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
     return leafValue;
   }
 
-  public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
+  public async checkNullifierExists(nullifier: Fr): Promise<boolean> {
     const timer = new Timer();
     const lowLeafResult = await this.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
     if (!lowLeafResult) {
@@ -472,13 +473,40 @@ export class PublicTreesDB extends ForwardMerkleTree implements PublicStateDBInt
     await this.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
     // TODO(fcarreiro): We need this for the hints. Might move it to the hinting layer.
     await this.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
-    const index = lowLeafResult.alreadyPresent ? lowLeafResult.index : undefined;
+    const exists = lowLeafResult.alreadyPresent;
 
-    this.logger.debug(`[DB] Fetched nullifier index`, {
+    this.logger.debug(`[DB] Checked nullifier exists`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
-      operation: 'get-nullifier-index',
+      operation: 'check-nullifier-exists',
     } satisfies PublicDBAccessStats);
-    return index;
+    return exists;
+  }
+
+  public async padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void> {
+    switch (treeId) {
+      // Indexed trees.
+      case MerkleTreeId.NULLIFIER_TREE:
+        await this.batchInsert(
+          treeId,
+          Array(leavesToInsert).fill(NullifierLeaf.empty().toBuffer()),
+          NULLIFIER_SUBTREE_HEIGHT,
+        );
+        break;
+      case MerkleTreeId.PUBLIC_DATA_TREE:
+        await this.batchInsert(
+          treeId,
+          Array(leavesToInsert).fill(PublicDataTreeLeaf.empty().toBuffer()),
+          PUBLIC_DATA_SUBTREE_HEIGHT,
+        );
+        break;
+      // Non-indexed trees.
+      case MerkleTreeId.L1_TO_L2_MESSAGE_TREE:
+      case MerkleTreeId.NOTE_HASH_TREE:
+        await this.appendLeaves(treeId, Array(leavesToInsert).fill(Fr.ZERO));
+        break;
+      default:
+        throw new Error(`Padding not supported for tree ${treeId}`);
+    }
   }
 }

package/src/public/public_processor/public_processor.ts

@@ -67,7 +67,6 @@ export class PublicProcessorFactory {
       globalVariables,
       /*doMerkleOperations=*/ true,
       skipFeeEnforcement,
-      this.telemetryClient,
     );
 
     return new PublicProcessor(
@@ -86,7 +85,6 @@ export class PublicProcessorFactory {
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
     skipFeeEnforcement: boolean,
-    telemetryClient: TelemetryClient,
   ): PublicTxSimulator {
     return new TelemetryPublicTxSimulator(
       treesDB,
@@ -94,7 +92,7 @@ export class PublicProcessorFactory {
       globalVariables,
       doMerkleOperations,
       skipFeeEnforcement,
-      telemetryClient,
+      this.telemetryClient,
     );
   }
 }

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -4,7 +4,6 @@ import {
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NULLIFIER_SUBTREE_HEIGHT,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
@@ -111,9 +110,16 @@ export class PublicTxContext {
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
     // We wrap the DB to collect AVM hints.
-    const hints = new AvmExecutionHints(AvmTxHint.fromTx(tx));
+    const hints = new AvmExecutionHints(await AvmTxHint.fromTx(tx));
     const hintingContractsDB = new HintingPublicContractsDB(contractsDB, hints);
     const hintingTreesDB = new HintingPublicTreesDB(treesDB, hints);
+    const startStateReference = await treesDB.getStateReference();
+    hints.startingTreeRoots = new TreeSnapshots(
+      startStateReference.l1ToL2MessageTree,
+      startStateReference.partial.noteHashTree,
+      startStateReference.partial.nullifierTree,
+      startStateReference.partial.publicDataTree,
+    );
 
     // Transaction level state manager that will be forked for revertible phases.
     const txStateManager = PublicPersistableStateManager.create(
@@ -394,16 +400,10 @@ export class PublicTxContext {
     );
     const numNoteHashesToPad =
       MAX_NOTE_HASHES_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.noteHashes);
-    await stateManager
-      .deprecatedGetTreesForPIGeneration()
-      .appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd([], Fr.ZERO, numNoteHashesToPad));
+    await stateManager.deprecatedGetTreesForPIGeneration().padTree(MerkleTreeId.NOTE_HASH_TREE, numNoteHashesToPad);
     const numNullifiersToPad =
       MAX_NULLIFIERS_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.nullifiers);
-    await stateManager.deprecatedGetTreesForPIGeneration().batchInsert(
-      MerkleTreeId.NULLIFIER_TREE,
-      padArrayEnd([], Fr.ZERO, numNullifiersToPad).map(nullifier => nullifier.toBuffer()),
-      NULLIFIER_SUBTREE_HEIGHT,
-    );
+    await stateManager.deprecatedGetTreesForPIGeneration().padTree(MerkleTreeId.NULLIFIER_TREE, numNullifiersToPad);
 
     const paddedState = await stateManager.deprecatedGetTreesForPIGeneration().getStateReference();
     avmCircuitPublicInputs.endTreeSnapshots = new TreeSnapshots(

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -69,7 +69,6 @@ export class PublicTxSimulator {
   public async simulate(tx: Tx): Promise<PublicTxResult> {
     try {
       const txHash = await this.computeTxHash(tx);
-
       this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, { txHash });
 
       const context = await PublicTxContext.create(
@@ -437,7 +436,7 @@ export class PublicTxSimulator {
   ): AvmProvingRequest {
     return {
       type: ProvingRequestType.PUBLIC_VM,
-      inputs: new AvmCircuitInputs('public_dispatch', [], hints, publicInputs),
+      inputs: new AvmCircuitInputs(hints, publicInputs),
     };
   }
 }

package/src/public/state_manager/nullifiers.ts

@@ -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/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 { PublicStateDBInterface } from '../../common/db_interfaces.js';
+import type { PublicStateDBInterface } from '../db_interfaces.js';
 
 type PublicStorageReadResult = {
   value: Fr;