@aztec/world-state 0.22.0 → 0.24.0

package/src/world-state-db/merkle_tree_operations_facade.ts

@@ -0,0 +1,182 @@
+import { L2Block, MerkleTreeId, SiblingPath } from '@aztec/circuit-types';
+import { Header, NullifierLeafPreimage, StateReference } from '@aztec/circuits.js';
+import { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+import { BatchInsertionResult } from '@aztec/merkle-tree';
+
+import { MerkleTreeDb } from './merkle_tree_db.js';
+import { HandleL2BlockResult, MerkleTreeOperations, TreeInfo } from './merkle_tree_operations.js';
+
+/**
+ * Wraps a MerkleTreeDbOperations to call all functions with a preset includeUncommitted flag.
+ */
+export class MerkleTreeOperationsFacade implements MerkleTreeOperations {
+  constructor(private trees: MerkleTreeDb, private includeUncommitted: boolean) {}
+
+  /**
+   * Returns the tree info for the specified tree id.
+   * @param treeId - Id of the tree to get information from.
+   * @param includeUncommitted - Indicates whether to include uncommitted data.
+   * @returns The tree info for the specified tree.
+   */
+  getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
+    return this.trees.getTreeInfo(treeId, this.includeUncommitted);
+  }
+
+  /**
+   * Get the current state reference.
+   * @returns The current state reference.
+   */
+  getStateReference(): Promise<StateReference> {
+    return this.trees.getStateReference(this.includeUncommitted);
+  }
+
+  /**
+   * Builds the initial header.
+   * @returns The initial header.
+   */
+  buildInitialHeader(): Promise<Header> {
+    return this.trees.buildInitialHeader(this.includeUncommitted);
+  }
+
+  /**
+   * Appends a set of leaf values to the tree.
+   * @param treeId - Id of the tree to append leaves to.
+   * @param leaves - The set of leaves to be appended.
+   * @returns The tree info of the specified tree.
+   */
+  appendLeaves(treeId: MerkleTreeId, leaves: Buffer[]): Promise<void> {
+    return this.trees.appendLeaves(treeId, leaves);
+  }
+
+  /**
+   * Returns the sibling path for a requested leaf index.
+   * @param treeId - Id of the tree to get the sibling path from.
+   * @param index - The index of the leaf for which a sibling path is required.
+   * @returns A promise with the sibling path of the specified leaf index.
+   */
+  async getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
+    const path = await this.trees.getSiblingPath(treeId, index, this.includeUncommitted);
+    return path as unknown as SiblingPath<N>;
+  }
+
+  /**
+   * Finds the index of the largest leaf whose value is less than or equal to the provided value.
+   * @param treeId - The ID of the tree to search.
+   * @param value - The value to be inserted into the tree.
+   * @param includeUncommitted - If true, the uncommitted changes are included in the search.
+   * @returns The found leaf index and a flag indicating if the corresponding leaf's value is equal to `newValue`.
+   */
+  getPreviousValueIndex(
+    treeId: MerkleTreeId.NULLIFIER_TREE,
+    value: bigint,
+  ): Promise<
+    | {
+        /**
+         * The index of the found leaf.
+         */
+        index: bigint;
+        /**
+         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+         */
+        alreadyPresent: boolean;
+      }
+    | undefined
+  > {
+    return this.trees.getPreviousValueIndex(treeId, value, this.includeUncommitted);
+  }
+
+  /**
+   * Updates a leaf in a tree at a given index.
+   * @param treeId - The ID of the tree.
+   * @param leaf - The new leaf value.
+   * @param index - The index to insert into.
+   * @returns Empty promise.
+   */
+  updateLeaf(treeId: MerkleTreeId.NULLIFIER_TREE, leaf: NullifierLeafPreimage, index: bigint): Promise<void> {
+    return this.trees.updateLeaf(treeId, leaf, index);
+  }
+
+  /**
+   * Gets the leaf data at a given index and tree.
+   * @param treeId - The ID of the tree get the leaf from.
+   * @param index - The index of the leaf to get.
+   * @returns Leaf preimage.
+   */
+  async getLeafPreimage(
+    treeId: MerkleTreeId.NULLIFIER_TREE,
+    index: bigint,
+  ): Promise<IndexedTreeLeafPreimage | undefined> {
+    const preimage = await this.trees.getLeafPreimage(treeId, index, this.includeUncommitted);
+    return preimage as IndexedTreeLeafPreimage | undefined;
+  }
+
+  /**
+   * Returns the index of a leaf given its value, or undefined if no leaf with that value is found.
+   * @param treeId - The ID of the tree.
+   * @param value - The leaf value to look for.
+   * @returns The index of the first leaf found with a given value (undefined if not found).
+   */
+  findLeafIndex(treeId: MerkleTreeId, value: Buffer): Promise<bigint | undefined> {
+    return this.trees.findLeafIndex(treeId, value, this.includeUncommitted);
+  }
+
+  /**
+   * Gets the value at the given index.
+   * @param treeId - The ID of the tree to get the leaf value from.
+   * @param index - The index of the leaf.
+   * @param includeUncommitted - Indicates whether to include uncommitted changes.
+   * @returns Leaf value at the given index (undefined if not found).
+   */
+  getLeafValue(treeId: MerkleTreeId, index: bigint): Promise<Buffer | undefined> {
+    return this.trees.getLeafValue(treeId, index, this.includeUncommitted);
+  }
+
+  /**
+   * Inserts the new block hash into the archive.
+   * This includes all of the current roots of all of the data trees and the current blocks global vars.
+   * @param header - The header to insert into the archive.
+   */
+  public updateArchive(header: Header): Promise<void> {
+    return this.trees.updateArchive(header, this.includeUncommitted);
+  }
+
+  /**
+   * Handles a single L2 block (i.e. Inserts the new commitments into the merkle tree).
+   * @param block - The L2 block to handle.
+   * @returns Whether the block handled was produced by this same node.
+   */
+  public handleL2Block(block: L2Block): Promise<HandleL2BlockResult> {
+    return this.trees.handleL2Block(block);
+  }
+
+  /**
+   * Commits all pending updates.
+   * @returns Empty promise.
+   */
+  public async commit(): Promise<void> {
+    return await this.trees.commit();
+  }
+
+  /**
+   * Rolls back all pending updates.
+   * @returns Empty promise.
+   */
+  public async rollback(): Promise<void> {
+    return await this.trees.rollback();
+  }
+
+  /**
+   * Batch insert multiple leaves into the tree.
+   * @param treeId - The ID of the tree.
+   * @param leaves - Leaves to insert into the tree.
+   * @param subtreeHeight - Height of the subtree.
+   * @returns The data for the leaves to be updated when inserting the new ones.
+   */
+  public batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number>(
+    treeId: MerkleTreeId,
+    leaves: Buffer[],
+    subtreeHeight: number,
+  ): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>> {
+    return this.trees.batchInsert(treeId, leaves, subtreeHeight);
+  }
+}

package/src/world-state-db/merkle_tree_snapshot_operations_facade.ts

@@ -0,0 +1,157 @@
+import { MerkleTreeId, SiblingPath } from '@aztec/circuit-types';
+import { AppendOnlyTreeSnapshot, Fr, Header, PartialStateReference, StateReference } from '@aztec/circuits.js';
+import { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+import { BatchInsertionResult, IndexedTreeSnapshot, TreeSnapshot } from '@aztec/merkle-tree';
+
+import { MerkleTreeDb } from './merkle_tree_db.js';
+import { HandleL2BlockResult, MerkleTreeOperations, TreeInfo } from './merkle_tree_operations.js';
+
+/**
+ * Merkle tree operations on readonly tree snapshots.
+ */
+export class MerkleTreeSnapshotOperationsFacade implements MerkleTreeOperations {
+  #treesDb: MerkleTreeDb;
+  #blockNumber: number;
+  #treeSnapshots: ReadonlyArray<TreeSnapshot | IndexedTreeSnapshot> = [];
+
+  constructor(trees: MerkleTreeDb, blockNumber: number) {
+    this.#treesDb = trees;
+    this.#blockNumber = blockNumber;
+  }
+
+  async #getTreeSnapshot(merkleTreeId: number): Promise<TreeSnapshot | IndexedTreeSnapshot> {
+    if (this.#treeSnapshots[merkleTreeId]) {
+      return this.#treeSnapshots[merkleTreeId];
+    }
+
+    this.#treeSnapshots = await this.#treesDb.getSnapshot(this.#blockNumber);
+    return this.#treeSnapshots[merkleTreeId]!;
+  }
+
+  async findLeafIndex(treeId: MerkleTreeId, value: Buffer): Promise<bigint | undefined> {
+    const tree = await this.#getTreeSnapshot(treeId);
+    return tree.findLeafIndex(value);
+  }
+
+  async getLeafPreimage(
+    treeId: MerkleTreeId.NULLIFIER_TREE,
+    index: bigint,
+  ): Promise<IndexedTreeLeafPreimage | undefined> {
+    const snapshot = (await this.#getTreeSnapshot(treeId)) as IndexedTreeSnapshot;
+    return snapshot.getLatestLeafPreimageCopy(BigInt(index));
+  }
+
+  async getLeafValue(treeId: MerkleTreeId, index: bigint): Promise<Buffer | undefined> {
+    const snapshot = await this.#getTreeSnapshot(treeId);
+    return snapshot.getLeafValue(BigInt(index));
+  }
+
+  async getPreviousValueIndex(
+    treeId: MerkleTreeId.NULLIFIER_TREE,
+    value: bigint,
+  ): Promise<
+    | {
+        /**
+         * The index of the found leaf.
+         */
+        index: bigint;
+        /**
+         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+         */
+        alreadyPresent: boolean;
+      }
+    | undefined
+  > {
+    const snapshot = (await this.#getTreeSnapshot(treeId)) as IndexedTreeSnapshot;
+    return snapshot.findIndexOfPreviousKey(value);
+  }
+
+  async getSiblingPath<N extends number>(treeId: MerkleTreeId, index: bigint): Promise<SiblingPath<N>> {
+    const snapshot = await this.#getTreeSnapshot(treeId);
+    return snapshot.getSiblingPath(index);
+  }
+
+  async getTreeInfo(treeId: MerkleTreeId): Promise<TreeInfo> {
+    const snapshot = await this.#getTreeSnapshot(treeId);
+    return {
+      depth: snapshot.getDepth(),
+      root: snapshot.getRoot(),
+      size: snapshot.getNumLeaves(),
+      treeId,
+    };
+  }
+
+  async getStateReference(): Promise<StateReference> {
+    const snapshots = await Promise.all([
+      this.#getTreeSnapshot(MerkleTreeId.CONTRACT_TREE),
+      this.#getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE),
+      this.#getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE),
+      this.#getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE),
+      this.#getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+      this.#getTreeSnapshot(MerkleTreeId.ARCHIVE),
+    ]);
+
+    return new StateReference(
+      new AppendOnlyTreeSnapshot(
+        Fr.fromBuffer(snapshots[MerkleTreeId.L1_TO_L2_MESSAGE_TREE].getRoot()),
+        Number(snapshots[MerkleTreeId.L1_TO_L2_MESSAGE_TREE].getNumLeaves()),
+      ),
+      new PartialStateReference(
+        new AppendOnlyTreeSnapshot(
+          Fr.fromBuffer(snapshots[MerkleTreeId.NOTE_HASH_TREE].getRoot()),
+          Number(snapshots[MerkleTreeId.NOTE_HASH_TREE].getNumLeaves()),
+        ),
+        new AppendOnlyTreeSnapshot(
+          Fr.fromBuffer(snapshots[MerkleTreeId.NULLIFIER_TREE].getRoot()),
+          Number(snapshots[MerkleTreeId.NULLIFIER_TREE].getNumLeaves()),
+        ),
+        new AppendOnlyTreeSnapshot(
+          Fr.fromBuffer(snapshots[MerkleTreeId.CONTRACT_TREE].getRoot()),
+          Number(snapshots[MerkleTreeId.CONTRACT_TREE].getNumLeaves()),
+        ),
+        new AppendOnlyTreeSnapshot(
+          Fr.fromBuffer(snapshots[MerkleTreeId.PUBLIC_DATA_TREE].getRoot()),
+          Number(snapshots[MerkleTreeId.PUBLIC_DATA_TREE].getNumLeaves()),
+        ),
+      ),
+    );
+  }
+
+  appendLeaves(): Promise<void> {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number>(): Promise<
+    BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>
+  > {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  updateArchive(): Promise<void> {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  commit(): Promise<void> {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  handleL2Block(): Promise<HandleL2BlockResult> {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  rollback(): Promise<void> {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  updateHistoricArchive(): Promise<void> {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  updateLeaf(): Promise<void> {
+    return Promise.reject(new Error('Tree snapshot operations are read-only'));
+  }
+
+  buildInitialHeader(): Promise<Header> {
+    throw new Error('Building initial header not supported on snapshot.');
+  }
+}