@aztec/simulator 0.0.0-test.0

package/src/public/fixtures/utils.ts

@@ -0,0 +1,199 @@
+import {
+  CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS,
+  DEFAULT_GAS_LIMIT,
+  DEPLOYER_CONTRACT_ADDRESS,
+  MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+  REGISTERER_CONTRACT_ADDRESS,
+  REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE,
+} from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { assertLength } from '@aztec/foundation/serialize';
+import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '@aztec/protocol-contracts';
+import { bufferAsFields } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import {
+  PartialPrivateTailPublicInputsForPublic,
+  PartialPrivateTailPublicInputsForRollup,
+  PrivateKernelTailCircuitPublicInputs,
+  RollupValidationRequests,
+  ScopedLogHash,
+  countAccumulatedItems,
+} from '@aztec/stdlib/kernel';
+import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
+import { type PublicExecutionRequest, Tx } from '@aztec/stdlib/tx';
+import { BlockHeader, TxConstantData, TxContext } from '@aztec/stdlib/tx';
+
+import { strict as assert } from 'assert';
+
+/**
+ * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
+ */
+export async function createTxForPublicCalls(
+  firstNullifier: Fr,
+  setupExecutionRequests: PublicExecutionRequest[],
+  appExecutionRequests: PublicExecutionRequest[],
+  teardownExecutionRequest?: PublicExecutionRequest,
+  feePayer = AztecAddress.zero(),
+  gasUsedByPrivate: Gas = Gas.empty(),
+): Promise<Tx> {
+  assert(
+    setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined,
+    "Can't create public tx with no enqueued calls",
+  );
+  const setupCallRequests = await Promise.all(setupExecutionRequests.map(er => er.toCallRequest()));
+  const appCallRequests = await Promise.all(appExecutionRequests.map(er => er.toCallRequest()));
+  // use max limits
+  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+
+  const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
+  // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
+  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier;
+
+  // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
+  for (let i = setupCallRequests.length - 1; i >= 0; i--) {
+    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i];
+  }
+  for (let i = appCallRequests.length - 1; i >= 0; i--) {
+    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
+  }
+  if (teardownExecutionRequest) {
+    forPublic.publicTeardownCallRequest = await teardownExecutionRequest.toCallRequest();
+  }
+
+  const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
+  const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
+  const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
+  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
+  const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+
+  const txData = new PrivateKernelTailCircuitPublicInputs(
+    constantData,
+    RollupValidationRequests.empty(),
+    /*gasUsed=*/ gasUsedByPrivate,
+    feePayer,
+    forPublic,
+  );
+  const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
+
+  // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
+  // Also push app calls before setup calls for this reason.
+  for (let i = appExecutionRequests.length - 1; i >= 0; i--) {
+    tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
+  }
+  for (let i = setupExecutionRequests.length - 1; i >= 0; i--) {
+    tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
+  }
+
+  return tx;
+}
+
+export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate: Gas = new Gas(10, 10)): Tx {
+  // use max limits
+  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+
+  const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
+
+  const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
+  const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
+  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
+  const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+
+  const txData = new PrivateKernelTailCircuitPublicInputs(
+    constantData,
+    RollupValidationRequests.empty(),
+    /*gasUsed=*/ gasUsedByPrivate,
+    feePayer,
+    /*forPublic=*/ undefined,
+    forRollup,
+  );
+  return Tx.newWithTxData(txData);
+}
+
+export async function addNewContractClassToTx(
+  tx: Tx,
+  contractClass: ContractClassPublic,
+  skipNullifierInsertion = false,
+) {
+  const contractClassLogFields = [
+    new Fr(REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE),
+    contractClass.id,
+    new Fr(contractClass.version),
+    new Fr(contractClass.artifactHash),
+    new Fr(contractClass.privateFunctionsRoot),
+    ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1),
+  ];
+  const contractClassLog = ContractClassLog.fromFields([
+    new Fr(REGISTERER_CONTRACT_ADDRESS),
+    ...contractClassLogFields.concat(
+      new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS - contractClassLogFields.length).fill(Fr.ZERO),
+    ),
+  ]);
+  const contractClassLogHash = ScopedLogHash.fromFields([
+    await contractClassLog.hash(),
+    new Fr(7),
+    new Fr(contractClassLog.getEmittedLength()),
+    new Fr(REGISTERER_CONTRACT_ADDRESS),
+  ]);
+
+  const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
+  if (!skipNullifierInsertion) {
+    const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
+    accumulatedData.nullifiers[nextNullifierIndex] = contractClass.id;
+  }
+
+  const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
+  accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
+
+  tx.contractClassLogs.push(contractClassLog);
+}
+
+export async function addNewContractInstanceToTx(
+  tx: Tx,
+  contractInstance: ContractInstanceWithAddress,
+  skipNullifierInsertion = false,
+) {
+  // can't use publicKeys.toFields() because it includes isInfinite which
+  // is not broadcast in such private logs
+  const publicKeysAsFields = [
+    contractInstance.publicKeys.masterNullifierPublicKey.x,
+    contractInstance.publicKeys.masterNullifierPublicKey.y,
+    contractInstance.publicKeys.masterIncomingViewingPublicKey.x,
+    contractInstance.publicKeys.masterIncomingViewingPublicKey.y,
+    contractInstance.publicKeys.masterOutgoingViewingPublicKey.x,
+    contractInstance.publicKeys.masterOutgoingViewingPublicKey.y,
+    contractInstance.publicKeys.masterTaggingPublicKey.x,
+    contractInstance.publicKeys.masterTaggingPublicKey.y,
+  ];
+  const fields = [
+    DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG,
+    contractInstance.address.toField(),
+    new Fr(contractInstance.version),
+    new Fr(contractInstance.salt),
+    contractInstance.currentContractClassId,
+    contractInstance.initializationHash,
+    ...publicKeysAsFields,
+    contractInstance.deployer.toField(),
+    new Fr(0),
+    new Fr(0),
+    new Fr(0),
+  ];
+  const contractInstanceLog = new PrivateLog(assertLength(fields, PRIVATE_LOG_SIZE_IN_FIELDS));
+
+  const contractAddressNullifier = await siloNullifier(
+    AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+    contractInstance.address.toField(),
+  );
+
+  const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
+  if (!skipNullifierInsertion) {
+    const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
+    accumulatedData.nullifiers[nextNullifierIndex] = contractAddressNullifier;
+  }
+
+  const nextLogIndex = countAccumulatedItems(accumulatedData.privateLogs);
+  accumulatedData.privateLogs[nextLogIndex] = contractInstanceLog;
+}

package/src/public/index.ts

@@ -0,0 +1,9 @@
+export * from '../common/db_interfaces.js';
+export * from './public_tx_simulator/public_tx_simulator.js';
+export { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult } from './execution.js';
+export * from './public_db_sources.js';
+export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
+export { SideEffectTrace } from './side_effect_trace.js';
+export { getExecutionRequestsByPhase } from './utils.js';
+export { PublicTxSimulationTester } from './fixtures/index.js';
+export * from './avm/index.js';

package/src/public/public_db_sources.ts

@@ -0,0 +1,369 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { ContractInstanceDeployedEvent } from '@aztec/protocol-contracts/instance-deployer';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractClassPublic,
+  type ContractDataSource,
+  type ContractInstanceWithAddress,
+  computePublicBytecodeCommitment,
+} from '@aztec/stdlib/contract';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import type {
+  MerkleTreeCheckpointOperations,
+  MerkleTreeReadOperations,
+  MerkleTreeWriteOperations,
+} 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 type { Tx } from '@aztec/stdlib/tx';
+
+import type { PublicContractsDB, PublicStateDB } from '../common/db_interfaces.js';
+import { TxContractCache } from './tx_contract_cache.js';
+
+/**
+ * Implements the PublicContractsDB using a ContractDataSource.
+ * Progressively records contracts in transaction as they are processed in a block.
+ * Separates block-level contract information (from processed/included txs) from the
+ * current tx's contract information (which may be cleared on tx revert/death).
+ */
+export class ContractsDataSourcePublicDB implements PublicContractsDB {
+  // Two caching layers for contract classes and instances.
+  // Tx-level cache:
+  //   - The current tx's new contract information is cached
+  //     in currentTxNonRevertibleCache and currentTxRevertibleCache.
+  // Block-level cache:
+  //   - Contract information from earlier in the block, usable by later txs.
+  // When a tx succeeds, that tx's caches are merged into the block cache and cleared.
+  private currentTxNonRevertibleCache = new TxContractCache();
+  private currentTxRevertibleCache = new TxContractCache();
+  private blockCache = new TxContractCache();
+  // Separate flat cache for bytecode commitments.
+  private bytecodeCommitmentCache = new Map<string, Fr>();
+
+  private log = createLogger('simulator:contracts-data-source');
+
+  constructor(private dataSource: ContractDataSource) {}
+
+  /**
+   * Add new contracts from a transaction
+   * @param tx - The transaction to add contracts from.
+   */
+  public async addNewContracts(tx: Tx): Promise<void> {
+    await this.addNonRevertibleContractClasses(tx);
+    await this.addRevertibleContractClasses(tx);
+    this.addNonRevertibleContractInstances(tx);
+    this.addRevertibleContractInstances(tx);
+  }
+
+  /**
+   * Add non revertible contracts from a transaction
+   * @param tx - The transaction to add non revertible contracts from.
+   */
+  public async addNewNonRevertibleContracts(tx: Tx) {
+    await this.addNonRevertibleContractClasses(tx);
+    this.addNonRevertibleContractInstances(tx);
+  }
+
+  /**
+   * Add revertible contracts from a transaction
+   * @param tx - The transaction to add revertible contracts from.
+   */
+  public async addNewRevertibleContracts(tx: Tx) {
+    await this.addRevertibleContractClasses(tx);
+    this.addRevertibleContractInstances(tx);
+  }
+
+  /**
+   * Add non-revertible contract classes from a transaction
+   * For private-only txs, this will be all contract classes (found in tx.data.forPublic)
+   * @param tx - The transaction to add non-revertible contract classes from.
+   */
+  private async addNonRevertibleContractClasses(tx: Tx) {
+    const siloedContractClassLogs = tx.data.forPublic
+      ? await tx.filterContractClassLogs(
+          tx.data.forPublic!.nonRevertibleAccumulatedData.contractClassLogsHashes,
+          /*siloed=*/ true,
+        )
+      : await tx.filterContractClassLogs(tx.data.forRollup!.end.contractClassLogsHashes, /*siloed=*/ true);
+
+    await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxNonRevertibleCache, 'non-revertible');
+  }
+
+  /**
+   * Add revertible contract classes from a transaction
+   * None for private-only txs.
+   * @param tx - The transaction to add revertible contract classes from.
+   */
+  private async addRevertibleContractClasses(tx: Tx) {
+    const siloedContractClassLogs = tx.data.forPublic
+      ? await tx.filterContractClassLogs(
+          tx.data.forPublic!.revertibleAccumulatedData.contractClassLogsHashes,
+          /*siloed=*/ true,
+        )
+      : [];
+
+    await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxRevertibleCache, 'revertible');
+  }
+
+  /**
+   * Add non-revertible contract instances from a transaction
+   * For private-only txs, this will be all contract instances (found in tx.data.forRollup)
+   * @param tx - The transaction to add non-revertible contract instances from.
+   */
+  private addNonRevertibleContractInstances(tx: Tx) {
+    const contractInstanceLogs = tx.data.forPublic
+      ? tx.data.forPublic!.nonRevertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty())
+      : tx.data.forRollup!.end.privateLogs.filter(l => !l.isEmpty());
+
+    this.addContractInstancesFromLogs(contractInstanceLogs, this.currentTxNonRevertibleCache, 'non-revertible');
+  }
+
+  /**
+   * Add revertible contract instances from a transaction
+   * None for private-only txs.
+   * @param tx - The transaction to add revertible contract instances from.
+   */
+  private addRevertibleContractInstances(tx: Tx) {
+    const contractInstanceLogs = tx.data.forPublic
+      ? tx.data.forPublic!.revertibleAccumulatedData.privateLogs.filter(l => !l.isEmpty())
+      : [];
+
+    this.addContractInstancesFromLogs(contractInstanceLogs, this.currentTxRevertibleCache, 'revertible');
+  }
+
+  /**
+   * Given a tx's siloed contract class logs, add the contract classes to the cache
+   * @param siloedContractClassLogs - Contract class logs to process
+   * @param cache - The cache to store the contract classes in
+   * @param cacheType - Type of cache (for logging)
+   */
+  private async addContractClassesFromLogs(
+    siloedContractClassLogs: ContractClassLog[],
+    cache: TxContractCache,
+    cacheType: string,
+  ) {
+    const contractClassEvents = siloedContractClassLogs
+      .filter((log: ContractClassLog) => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
+      .map((log: ContractClassLog) => ContractClassRegisteredEvent.fromLog(log));
+
+    // Cache contract classes
+    await Promise.all(
+      contractClassEvents.map(async (event: ContractClassRegisteredEvent) => {
+        this.log.debug(`Adding class ${event.contractClassId.toString()} to contract's ${cacheType} tx cache`);
+        const contractClass = await event.toContractClassPublic();
+
+        cache.addClass(event.contractClassId, contractClass);
+      }),
+    );
+  }
+
+  /**
+   * Given a tx's contract instance logs, add the contract instances to the cache
+   * @param contractInstanceLogs - Contract instance logs to process
+   * @param cache - The cache to store the contract instances in
+   * @param cacheType - Type of cache (for logging)
+   */
+  private addContractInstancesFromLogs(contractInstanceLogs: PrivateLog[], cache: TxContractCache, cacheType: string) {
+    const contractInstanceEvents = contractInstanceLogs
+      .filter(log => ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log))
+      .map(log => ContractInstanceDeployedEvent.fromLog(log));
+
+    // Cache contract instances
+    contractInstanceEvents.forEach(e => {
+      this.log.debug(
+        `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to ${cacheType} tx contract cache`,
+      );
+      cache.addInstance(e.address, e.toContractInstance());
+    });
+  }
+
+  /**
+   * Clear new contracts from the current tx's cache
+   */
+  public clearContractsForTx() {
+    this.currentTxRevertibleCache.clear();
+    this.currentTxRevertibleCache.clear();
+    this.currentTxNonRevertibleCache.clear();
+  }
+
+  /**
+   * Commits the current transaction's cached contracts to the block-level cache.
+   * Then, clears the tx cache.
+   */
+  public commitContractsForTx(onlyNonRevertibles: boolean = false) {
+    // Merge non-revertible tx cache into block cache
+    this.blockCache.mergeFrom(this.currentTxNonRevertibleCache);
+
+    if (!onlyNonRevertibles) {
+      // Merge revertible tx cache into block cache
+      this.blockCache.mergeFrom(this.currentTxRevertibleCache);
+    }
+
+    // Clear the tx's caches
+    this.currentTxNonRevertibleCache.clear();
+    this.currentTxRevertibleCache.clear();
+  }
+
+  public async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    // Check caches in order: tx revertible -> tx non-revertible -> block -> data source
+    return (
+      this.currentTxRevertibleCache.getInstance(address) ??
+      this.currentTxNonRevertibleCache.getInstance(address) ??
+      this.blockCache.getInstance(address) ??
+      (await this.dataSource.getContract(address))
+    );
+  }
+
+  public async getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined> {
+    // Check caches in order: tx revertible -> tx non-revertible -> block -> data source
+    return (
+      this.currentTxRevertibleCache.getClass(contractClassId) ??
+      this.currentTxNonRevertibleCache.getClass(contractClassId) ??
+      this.blockCache.getClass(contractClassId) ??
+      (await this.dataSource.getContractClass(contractClassId))
+    );
+  }
+
+  public async getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
+    // Try and retrieve from cache
+    const key = contractClassId.toString();
+    const result = this.bytecodeCommitmentCache.get(key);
+    if (result !== undefined) {
+      return result;
+    }
+    // Now try from the store
+    const fromStore = await this.dataSource.getBytecodeCommitment(contractClassId);
+    if (fromStore !== undefined) {
+      this.bytecodeCommitmentCache.set(key, fromStore);
+      return fromStore;
+    }
+
+    // Not in either the store or the cache, build it here and cache
+    const contractClass = await this.getContractClass(contractClassId);
+    if (contractClass === undefined) {
+      return undefined;
+    }
+
+    const value = await computePublicBytecodeCommitment(contractClass.packedBytecode);
+    this.bytecodeCommitmentCache.set(key, value);
+    return value;
+  }
+
+  public async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    return await this.dataSource.getContractFunctionName(address, selector);
+  }
+}
+
+/**
+ * A public state DB that reads and writes to the world state.
+ */
+export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicStateDB, MerkleTreeCheckpointOperations {
+  private logger = createLogger('simulator:world-state-db');
+
+  constructor(public db: MerkleTreeWriteOperations, dataSource: ContractDataSource) {
+    super(dataSource);
+  }
+
+  /**
+   * Checkpoints the current fork state
+   */
+  public async createCheckpoint() {
+    await this.db.createCheckpoint();
+  }
+
+  /**
+   * Commits the current checkpoint
+   */
+  public async commitCheckpoint() {
+    await this.db.commitCheckpoint();
+  }
+
+  /**
+   * Reverts the current checkpoint
+   */
+  public async revertCheckpoint() {
+    await this.db.revertCheckpoint();
+  }
+
+  public getMerkleInterface(): MerkleTreeWriteOperations {
+    return this.db;
+  }
+
+  /**
+   * Reads a value from public storage, returning zero if none.
+   * @param contract - Owner of the storage.
+   * @param slot - Slot to read in the contract storage.
+   * @returns The current value in the storage slot.
+   */
+  public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
+    return await readPublicState(this.db, contract, slot);
+  }
+
+  /**
+   * Records a write to public storage.
+   * @param contract - Owner of the storage.
+   * @param slot - Slot to read in the contract storage.
+   * @param newValue - The new value to store.
+   * @returns The slot of the written leaf in the public data tree.
+   */
+  public async storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
+    const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
+    const publicDataWrite = new PublicDataWrite(leafSlot, newValue);
+    await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
+  }
+
+  public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined> {
+    const timer = new Timer();
+    const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    this.logger.debug(`[DB] Fetched L1 to L2 message leaf value`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-l1-to-l2-message-leaf-value',
+    } satisfies PublicDBAccessStats);
+    return leafValue;
+  }
+
+  public async getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined> {
+    const timer = new Timer();
+    const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+    this.logger.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.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
+    this.logger.debug(`[DB] Fetched nullifier index`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-nullifier-index',
+    } satisfies PublicDBAccessStats);
+    return index;
+  }
+}
+
+export async function readPublicState(db: MerkleTreeReadOperations, contract: AztecAddress, slot: Fr): Promise<Fr> {
+  const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
+
+  const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+  if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+    return Fr.ZERO;
+  }
+
+  const preimage = (await db.getLeafPreimage(
+    MerkleTreeId.PUBLIC_DATA_TREE,
+    lowLeafResult.index,
+  )) as PublicDataTreeLeafPreimage;
+
+  return preimage.value;
+}