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

package/src/public/public_db_sources.ts

@@ -1,8 +1,9 @@
+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';
-import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
-import { ContractInstanceDeployedEvent } from '@aztec/protocol-contracts/instance-deployer';
+import { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
+import { ContractInstancePublishedEvent } from '@aztec/protocol-contracts/instance-registry';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -13,26 +14,29 @@ import {
   computePublicBytecodeCommitment,
 } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import type {
-  MerkleTreeCheckpointOperations,
-  MerkleTreeReadOperations,
-  MerkleTreeWriteOperations,
-} from '@aztec/stdlib/interfaces/server';
+import type { 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 {
+  MerkleTreeId,
+  NullifierLeaf,
+  PublicDataTreeLeaf,
+  type PublicDataTreeLeafPreimage,
+  getTreeName,
+} from '@aztec/stdlib/trees';
+import { TreeSnapshots, type Tx } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+import type { PublicContractsDBInterface, PublicStateDBInterface } from './db_interfaces.js';
 import { TxContractCache } from './tx_contract_cache.js';
 
 /**
- * Implements the PublicContractsDB using a ContractDataSource.
+ * Implements the PublicContractsDBInterface 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 {
+export class PublicContractsDB implements PublicContractsDBInterface {
   // Two caching layers for contract classes and instances.
   // Tx-level cache:
   //   - The current tx's new contract information is cached
@@ -86,12 +90,8 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    */
   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);
-
+      ? tx.getSplitContractClassLogs(false /* revertible */)
+      : tx.getContractClassLogs();
     await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxNonRevertibleCache, 'non-revertible');
   }
 
@@ -101,13 +101,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    * @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,
-        )
-      : [];
-
+    const siloedContractClassLogs = tx.data.forPublic ? tx.getSplitContractClassLogs(true /* revertible */) : [];
     await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxRevertibleCache, 'revertible');
   }
 
@@ -149,12 +143,12 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     cacheType: string,
   ) {
     const contractClassEvents = siloedContractClassLogs
-      .filter((log: ContractClassLog) => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log))
-      .map((log: ContractClassLog) => ContractClassRegisteredEvent.fromLog(log));
+      .filter((log: ContractClassLog) => ContractClassPublishedEvent.isContractClassPublishedEvent(log))
+      .map((log: ContractClassLog) => ContractClassPublishedEvent.fromLog(log));
 
     // Cache contract classes
     await Promise.all(
-      contractClassEvents.map(async (event: ContractClassRegisteredEvent) => {
+      contractClassEvents.map(async (event: ContractClassPublishedEvent) => {
         this.log.debug(`Adding class ${event.contractClassId.toString()} to contract's ${cacheType} tx cache`);
         const contractClass = await event.toContractClassPublic();
 
@@ -171,8 +165,8 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    */
   private addContractInstancesFromLogs(contractInstanceLogs: PrivateLog[], cache: TxContractCache, cacheType: string) {
     const contractInstanceEvents = contractInstanceLogs
-      .filter(log => ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log))
-      .map(log => ContractInstanceDeployedEvent.fromLog(log));
+      .filter(log => ContractInstancePublishedEvent.isContractInstancePublishedEvent(log))
+      .map(log => ContractInstancePublishedEvent.fromLog(log));
 
     // Cache contract instances
     contractInstanceEvents.forEach(e => {
@@ -210,13 +204,25 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     this.currentTxRevertibleCache.clear();
   }
 
-  public async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+  // TODO(fcarreiro/alvaro): This method currently needs a blockNumber. Since this class
+  // is only ever used for a given block, it should be possible to construct it with the
+  // block number and then forget about it. However, since this class (and interface) is
+  // currently more externally exposed than we'd want to, Facundo preferred to not add it
+  // to the constructor right now. If we can make this class more private, we should
+  // reconsider this. A litmus test is in how many places we need to initialize with a
+  // dummy block number (tests or not) and pass block numbers to `super`.
+  // Note: Block number got changed to timestamp so this comment ^ is outdated. Keeping
+  // the comment as is as I am not part of the AVM cabal.
+  public async getContractInstance(
+    address: AztecAddress,
+    timestamp: UInt64,
+  ): 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))
+      (await this.dataSource.getContract(address, timestamp))
     );
   }
 
@@ -256,72 +262,74 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
   }
 
   public async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    return await this.dataSource.getContractFunctionName(address, selector);
+    return await this.dataSource.getDebugFunctionName(address, selector);
   }
 }
 
 /**
- * A public state DB that reads and writes to the world state.
+ * A high-level class that provides access to the merkle trees.
+ *
+ * This class is just a helper wrapper around a merkle db. Anything that you can do with it
+ * can also be done directly with the merkle db. This class should NOT be exposed or used
+ * outside of `simulator/src/public`.
+ *
+ * NOTE: This class is currently written in such a way that it would generate the
+ * necessary hints if used with a hinting merkle db. This is a bit of a leak of concepts.
+ * Eventually we can have everything depend on a config/factory at the TxSimulator level
+ * to decide whether to use hints or not (same with tracing, etc).
  */
-export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicStateDB, MerkleTreeCheckpointOperations {
-  private logger = createLogger('simulator:world-state-db');
+export class PublicTreesDB implements PublicStateDBInterface {
+  private logger = createLogger('simulator:public-trees-db');
 
-  constructor(public db: MerkleTreeWriteOperations, dataSource: ContractDataSource) {
-    super(dataSource);
-  }
+  constructor(private readonly db: MerkleTreeWriteOperations) {}
 
-  /**
-   * Checkpoints the current fork state
-   */
-  public async createCheckpoint() {
-    await this.db.createCheckpoint();
-  }
+  public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
+    const timer = new Timer();
+    const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
 
-  /**
-   * Commits the current checkpoint
-   */
-  public async commitCheckpoint() {
-    await this.db.commitCheckpoint();
-  }
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!lowLeafResult) {
+      throw new Error('Low leaf not found');
+    }
 
-  /**
-   * Reverts the current checkpoint
-   */
-  public async revertCheckpoint() {
-    await this.db.revertCheckpoint();
-  }
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+    // Unconditionally fetching the preimage for the hints. Move it to the hinting layer?
+    const preimage = (await this.db.getLeafPreimage(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      lowLeafResult.index,
+    )) as PublicDataTreeLeafPreimage;
 
-  public getMerkleInterface(): MerkleTreeWriteOperations {
-    return this.db;
-  }
+    const result = lowLeafResult.alreadyPresent ? preimage.leaf.value : Fr.ZERO;
+    this.logger.debug(`Storage read (contract=${contract}, slot=${slot}, value=${result})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'storage-read',
+    } satisfies PublicDBAccessStats);
 
-  /**
-   * 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);
+    return result;
   }
 
-  /**
-   * 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 timer = new Timer();
     const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
     const publicDataWrite = new PublicDataWrite(leafSlot, newValue);
     await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()]);
+
+    this.logger.debug(`Storage write (contract=${contract}, slot=${slot}, value=${newValue})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'storage-write',
+    } satisfies PublicDBAccessStats);
   }
 
   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`, {
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+
+    this.logger.debug(`Fetched L1 to L2 message leaf value (leafIndex=${leafIndex}, value=${leafValue})`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-l1-to-l2-message-leaf-value',
@@ -329,41 +337,116 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
     return leafValue;
   }
 
-  public async getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined> {
+  public async getNoteHash(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`, {
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+
+    this.logger.debug(`Fetched note hash leaf value (leafIndex=${leafIndex}, value=${leafValue})`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
-      operation: 'get-commitment-leaf-value',
+      operation: 'get-note-hash',
     } satisfies PublicDBAccessStats);
     return leafValue;
   }
 
-  public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
+  public async writeNoteHash(noteHash: Fr): Promise<void> {
     const timer = new Timer();
-    const index = (await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [nullifier.toBuffer()]))[0];
-    this.logger.debug(`[DB] Fetched nullifier index`, {
+    await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [noteHash]);
+
+    this.logger.debug(`Wrote note hash (noteHash=${noteHash})`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
-      operation: 'get-nullifier-index',
+      operation: 'write-note-hash',
     } satisfies PublicDBAccessStats);
-    return index;
   }
-}
 
-export async function readPublicState(db: MerkleTreeReadOperations, contract: AztecAddress, slot: Fr): Promise<Fr> {
-  const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
+  public async checkNullifierExists(nullifier: Fr): Promise<boolean> {
+    const timer = new Timer();
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+    if (!lowLeafResult) {
+      throw new Error('Low leaf not found');
+    }
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+    // TODO: We need this for the hints. See class comment for more details.
+    await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, lowLeafResult.index);
+    const exists = lowLeafResult.alreadyPresent;
+
+    this.logger.debug(`Checked nullifier exists (nullifier=${nullifier}, exists=${exists})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'check-nullifier-exists',
+    } satisfies PublicDBAccessStats);
+    return exists;
+  }
+
+  public async writeNullifier(siloedNullifier: Fr): Promise<void> {
+    const timer = new Timer();
+    await this.db.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()]);
 
-  const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-  if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
-    return Fr.ZERO;
+    this.logger.debug(`Wrote nullifier (nullifier=${siloedNullifier})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'write-nullifier',
+    } satisfies PublicDBAccessStats);
   }
 
-  const preimage = (await db.getLeafPreimage(
-    MerkleTreeId.PUBLIC_DATA_TREE,
-    lowLeafResult.index,
-  )) as PublicDataTreeLeafPreimage;
+  public async padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void> {
+    const timer = new Timer();
 
-  return preimage.value;
+    switch (treeId) {
+      // Indexed trees.
+      case MerkleTreeId.NULLIFIER_TREE:
+        await this.db.batchInsert(
+          treeId,
+          Array(leavesToInsert).fill(NullifierLeaf.empty().toBuffer()),
+          NULLIFIER_SUBTREE_HEIGHT,
+        );
+        break;
+      case MerkleTreeId.PUBLIC_DATA_TREE:
+        await this.db.batchInsert(
+          treeId,
+          Array(leavesToInsert).fill(PublicDataTreeLeaf.empty().toBuffer()),
+          PUBLIC_DATA_SUBTREE_HEIGHT,
+        );
+        break;
+      // Append-only trees.
+      case MerkleTreeId.L1_TO_L2_MESSAGE_TREE:
+      case MerkleTreeId.NOTE_HASH_TREE:
+        await this.db.appendLeaves(treeId, Array(leavesToInsert).fill(Fr.ZERO));
+        break;
+      default:
+        throw new Error(`Padding not supported for tree ${treeId}`);
+    }
+
+    this.logger.debug(`Padded tree (tree=${getTreeName(treeId)}, leavesToInsert=${leavesToInsert})`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'pad-tree',
+    } satisfies PublicDBAccessStats);
+  }
+
+  public async createCheckpoint(): Promise<void> {
+    await this.db.createCheckpoint();
+  }
+
+  public async commitCheckpoint(): Promise<void> {
+    await this.db.commitCheckpoint();
+  }
+
+  public async revertCheckpoint(): Promise<void> {
+    await this.db.revertCheckpoint();
+  }
+
+  public async getTreeSnapshots(): Promise<TreeSnapshots> {
+    const stateReference = await this.db.getStateReference();
+    return new TreeSnapshots(
+      stateReference.l1ToL2MessageTree,
+      stateReference.partial.noteHashTree,
+      stateReference.partial.nullifierTree,
+      stateReference.partial.publicDataTree,
+    );
+  }
 }

package/src/public/public_processor/guarded_merkle_tree.ts

@@ -0,0 +1,149 @@
+import { SerialQueue } from '@aztec/foundation/queue';
+import type { IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
+import type {
+  BatchInsertionResult,
+  IndexedTreeId,
+  MerkleTreeId,
+  MerkleTreeLeafType,
+  MerkleTreeWriteOperations,
+  SequentialInsertionResult,
+  TreeHeights,
+  TreeInfo,
+} from '@aztec/stdlib/trees';
+import type { BlockHeader, StateReference } from '@aztec/stdlib/tx';
+
+/**
+ * Wraps an instance of `MerkleTreeWriteOperations` to allow the sequencer to gate access.
+ * If transactions execution goes past the deadline, the simulator will continue to execute and update the world state
+ * The public processor however requires that the world state remain constant after the deadline in order to finalize the block
+ * The public processor provides this implementation of MerkleTreeWriteOperations to the simulator
+ */
+
+export class GuardedMerkleTreeOperations implements MerkleTreeWriteOperations {
+  private isStopped = false;
+  private serialQueue = new SerialQueue();
+
+  constructor(private target: MerkleTreeWriteOperations) {
+    this.serialQueue.start();
+  }
+
+  private guard() {
+    if (this.isStopped) {
+      throw new Error('Merkle tree access has been stopped');
+    }
+  }
+
+  // Executes the provided function only if the guard is not stopped.
+  private guardAndPush<T>(fn: () => Promise<T>): Promise<T> {
+    this.guard();
+    return this.serialQueue.put(() => {
+      this.guard();
+      return fn();
+    });
+  }
+
+  public getUnderlyingFork(): MerkleTreeWriteOperations {
+    return this.target;
+  }
+
+  // Stops all further access to the merkle trees via this object
+  async stop(): Promise<void> {
+    await this.serialQueue.put(() => {
+      this.isStopped = true;
+      return Promise.resolve();
+    });
+    return this.serialQueue.end();
+  }
+
+  // Proxy all methods to the target
+  appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void> {
+    return this.guardAndPush(() => this.target.appendLeaves(treeId, leaves));
+  }
+
+  updateArchive(header: BlockHeader): Promise<void> {
+    return this.guardAndPush(() => this.target.updateArchive(header));
+  }
+  batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number, ID extends IndexedTreeId>(
+    treeId: ID,
+    leaves: Buffer[],
+    subtreeHeight: number,
+  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>> {
+    return this.guardAndPush(() => this.target.batchInsert(treeId, leaves, subtreeHeight));
+  }
+  sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(
+    treeId: ID,
+    leaves: Buffer[],
+  ): Promise<SequentialInsertionResult<TreeHeight>> {
+    return this.guardAndPush(() => this.target.sequentialInsert(treeId, leaves));
+  }
+  close(): Promise<void> {
+    return this.guardAndPush(() => this.target.close());
+  }
+  getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
+    return this.guardAndPush(() => this.target.getTreeInfo(treeId));
+  }
+  getStateReference(): Promise<StateReference> {
+    return this.guardAndPush(() => this.target.getStateReference());
+  }
+  getInitialHeader(): BlockHeader {
+    return this.target.getInitialHeader();
+  }
+  getSiblingPath<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<SiblingPath<TreeHeights[ID]>> {
+    return this.guardAndPush(() => this.target.getSiblingPath(treeId, index));
+  }
+  getPreviousValueIndex<ID extends IndexedTreeId>(
+    treeId: ID,
+    value: bigint,
+  ): Promise<{ index: bigint; alreadyPresent: boolean } | undefined> {
+    return this.guardAndPush(() => this.target.getPreviousValueIndex(treeId, value));
+  }
+  getLeafPreimage<ID extends IndexedTreeId>(treeId: ID, index: bigint): Promise<IndexedTreeLeafPreimage | undefined> {
+    return this.guardAndPush(() => this.target.getLeafPreimage(treeId, index));
+  }
+  findLeafIndices<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+  ): Promise<(bigint | undefined)[]> {
+    return this.guardAndPush(() => this.target.findLeafIndices(treeId, values));
+  }
+  findLeafIndicesAfter<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+    startIndex: bigint,
+  ): Promise<(bigint | undefined)[]> {
+    return this.guardAndPush(() => this.target.findLeafIndicesAfter(treeId, values, startIndex));
+  }
+  getLeafValue<ID extends MerkleTreeId>(
+    treeId: ID,
+    index: bigint,
+  ): Promise<MerkleTreeLeafType<typeof treeId> | undefined> {
+    return this.guardAndPush(() => this.target.getLeafValue(treeId, index));
+  }
+  getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(
+    treeId: ID,
+    leafIndices: bigint[],
+  ): Promise<(bigint | undefined)[]> {
+    return this.guardAndPush(() => this.target.getBlockNumbersForLeafIndices(treeId, leafIndices));
+  }
+  createCheckpoint(): Promise<void> {
+    return this.guardAndPush(() => this.target.createCheckpoint());
+  }
+  commitCheckpoint(): Promise<void> {
+    return this.guardAndPush(() => this.target.commitCheckpoint());
+  }
+  revertCheckpoint(): Promise<void> {
+    return this.guardAndPush(() => this.target.revertCheckpoint());
+  }
+  commitAllCheckpoints(): Promise<void> {
+    return this.guardAndPush(() => this.target.commitAllCheckpoints());
+  }
+  revertAllCheckpoints(): Promise<void> {
+    return this.guardAndPush(() => this.target.revertAllCheckpoints());
+  }
+  findSiblingPaths<ID extends MerkleTreeId>(
+    treeId: ID,
+    values: MerkleTreeLeafType<ID>[],
+  ): Promise<({ path: SiblingPath<TreeHeights[ID]>; index: bigint } | undefined)[]> {
+    return this.guardAndPush(() => this.target.findSiblingPaths(treeId, values));
+  }
+}