@aztec/merkle-tree 0.16.1 → 0.16.2

package/src/standard_indexed_tree/test/standard_indexed_tree_with_append.ts

@@ -1,6 +1,4 @@
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-
-import { LeafData, StandardIndexedTree } from '../../index.js';
+import { StandardIndexedTree } from '../../index.js';
 
 /**
  * A testing utility which is here to store the original implementation of StandardIndexedTree.appendLeaves method
@@ -26,10 +24,10 @@ export class StandardIndexedTreeWithAppend extends StandardIndexedTree {
    * @returns Empty promise.
    */
   private async appendLeaf(leaf: Buffer): Promise<void> {
-    const newValue = toBigIntBE(leaf);
+    const newLeaf = this.leafFactory.fromBuffer(leaf);
 
     // Special case when appending zero
-    if (newValue === 0n) {
+    if (newLeaf.getKey() === 0n) {
       const newSize = (this.cachedSize ?? this.size) + 1n;
       if (newSize - 1n > this.maxIndex) {
         throw Error(`Can't append beyond max index. Max index: ${this.maxIndex}`);
@@ -38,27 +36,31 @@ export class StandardIndexedTreeWithAppend extends StandardIndexedTree {
       return;
     }
 
-    const indexOfPrevious = this.findIndexOfPreviousValue(newValue, true);
-    const previousLeafCopy = this.getLatestLeafDataCopy(indexOfPrevious.index, true);
-
-    if (previousLeafCopy === undefined) {
+    const lowLeafIndex = await this.findIndexOfPreviousKey(newLeaf.getKey(), true);
+    if (lowLeafIndex === undefined) {
       throw new Error(`Previous leaf not found!`);
     }
-    const newLeaf = {
-      value: newValue,
-      nextIndex: previousLeafCopy.nextIndex,
-      nextValue: previousLeafCopy.nextValue,
-    } as LeafData;
-    if (indexOfPrevious.alreadyPresent) {
+    const lowLeafPreimage = (await this.getLatestLeafPreimageCopy(lowLeafIndex.index, true))!;
+
+    const newLeafPreimage = this.leafPreimageFactory.fromLeaf(
+      newLeaf,
+      lowLeafPreimage.getNextKey(),
+      lowLeafPreimage.getNextIndex(),
+    );
+
+    if (lowLeafIndex.alreadyPresent) {
       return;
     }
     // insert a new leaf at the highest index and update the values of our previous leaf copy
     const currentSize = this.getNumLeaves(true);
-    previousLeafCopy.nextIndex = BigInt(currentSize);
-    previousLeafCopy.nextValue = newLeaf.value;
-    this.cachedLeaves[Number(currentSize)] = newLeaf;
-    this.cachedLeaves[Number(indexOfPrevious.index)] = previousLeafCopy;
-    await this.updateLeaf(previousLeafCopy, BigInt(indexOfPrevious.index));
-    await this.updateLeaf(newLeaf, this.getNumLeaves(true));
+    const newLowLeafPreimage = this.leafPreimageFactory.fromLeaf(
+      lowLeafPreimage.asLeaf(),
+      newLeaf.getKey(),
+      BigInt(currentSize),
+    );
+    this.cachedLeafPreimages[Number(currentSize)] = newLeafPreimage;
+    this.cachedLeafPreimages[Number(lowLeafIndex.index)] = newLowLeafPreimage;
+    await this.updateLeaf(newLowLeafPreimage, BigInt(lowLeafIndex.index));
+    await this.updateLeaf(newLeafPreimage, this.getNumLeaves(true));
   }
 }

package/src/standard_tree/standard_tree.ts

@@ -1,3 +1,4 @@
+import { AppendOnlySnapshotBuilder, TreeSnapshot } from '../index.js';
 import { AppendOnlyTree } from '../interfaces/append_only_tree.js';
 import { TreeBase } from '../tree_base.js';
 
@@ -5,6 +6,8 @@ import { TreeBase } from '../tree_base.js';
  * A Merkle tree implementation that uses a LevelDB database to store the tree.
  */
 export class StandardTree extends TreeBase implements AppendOnlyTree {
+  #snapshotBuilder = new AppendOnlySnapshotBuilder(this.db, this, this.hasher);
+
   /**
    * Appends the given leaves to the tree.
    * @param leaves - The leaves to append.
@@ -13,4 +16,22 @@ export class StandardTree extends TreeBase implements AppendOnlyTree {
   public async appendLeaves(leaves: Buffer[]): Promise<void> {
     await super.appendLeaves(leaves);
   }
+
+  public snapshot(block: number): Promise<TreeSnapshot> {
+    return this.#snapshotBuilder.snapshot(block);
+  }
+
+  public getSnapshot(block: number): Promise<TreeSnapshot> {
+    return this.#snapshotBuilder.getSnapshot(block);
+  }
+
+  public async findLeafIndex(value: Buffer, includeUncommitted: boolean): Promise<bigint | undefined> {
+    for (let i = 0n; i < this.getNumLeaves(includeUncommitted); i++) {
+      const currentValue = await this.getLeafValue(i, includeUncommitted);
+      if (currentValue && currentValue.equals(value)) {
+        return i;
+      }
+    }
+    return undefined;
+  }
 }

package/src/tree_base.ts

@@ -150,6 +150,26 @@ export abstract class TreeBase implements MerkleTree {
     return this.getLatestValueAtIndex(this.depth, index, includeUncommitted);
   }
 
+  public getNode(level: number, index: bigint): Promise<Buffer | undefined> {
+    if (level < 0 || level > this.depth) {
+      throw Error('Invalid level: ' + level);
+    }
+
+    if (index < 0 || index >= 2n ** BigInt(level)) {
+      throw Error('Invalid index: ' + index);
+    }
+
+    return this.dbGet(indexToKeyHash(this.name, level, index));
+  }
+
+  public getZeroHash(level: number): Buffer {
+    if (level <= 0 || level > this.depth) {
+      throw new Error('Invalid level');
+    }
+
+    return this.zeroHashes[level - 1];
+  }
+
   /**
    * Clears the cache.
    */
@@ -221,13 +241,6 @@ export abstract class TreeBase implements MerkleTree {
     await this.writeMeta();
   }
 
-  /**
-   * Initializes the tree from the database.
-   */
-  public async initFromDb(): Promise<void> {
-    // Implemented only by Indexed Tree to populate the leaf cache.
-  }
-
   /**
    * Writes meta data to the provided batch.
    * @param batch - The batch to which to write the meta data.
@@ -287,4 +300,12 @@ export abstract class TreeBase implements MerkleTree {
     }
     this.cachedSize = numLeaves + BigInt(leaves.length);
   }
+
+  /**
+   * Returns the index of a leaf given its value, or undefined if no leaf with that value is found.
+   * @param value - The leaf value to look for.
+   * @param includeUncommitted - Indicates whether to include uncommitted data.
+   * @returns The index of the first leaf found with a given value (undefined if not found).
+   */
+  abstract findLeafIndex(value: Buffer, includeUncommitted: boolean): Promise<bigint | undefined>;
 }