@aztec/merkle-tree 0.20.0 → 0.21.0

package/dest/standard_indexed_tree/standard_indexed_tree.d.ts

@@ -1,38 +1,13 @@
 /// <reference types="node" resolution-mode="require"/>
 import { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
 import { Hasher } from '@aztec/types/interfaces';
 import { SiblingPath } from '@aztec/types/membership';
-import { LevelUp } from 'levelup';
-import { BatchInsertionResult, IndexedTree, IndexedTreeSnapshot } from '../index.js';
+import { BatchInsertionResult, IndexedTree, PreimageFactory } from '../interfaces/indexed_tree.js';
+import { IndexedTreeSnapshot } from '../snapshots/snapshot_builder.js';
 import { TreeBase } from '../tree_base.js';
-/**
- * Factory for creating leaf preimages.
- */
-export interface PreimageFactory {
-    /**
-     * Creates a new preimage from a leaf.
-     * @param leaf - Leaf to create a preimage from.
-     * @param nextKey - Next key of the leaf.
-     * @param nextIndex - Next index of the leaf.
-     */
-    fromLeaf(leaf: IndexedTreeLeaf, nextKey: bigint, nextIndex: bigint): IndexedTreeLeafPreimage;
-    /**
-     * Creates a new preimage from a buffer.
-     * @param buffer - Buffer to create a preimage from.
-     */
-    fromBuffer(buffer: Buffer): IndexedTreeLeafPreimage;
-    /**
-     * Creates an empty preimage.
-     */
-    empty(): IndexedTreeLeafPreimage;
-    /**
-     * Creates a copy of a preimage.
-     * @param preimage - Preimage to be cloned.
-     */
-    clone(preimage: IndexedTreeLeafPreimage): IndexedTreeLeafPreimage;
-}
-export declare const buildDbKeyForPreimage: (name: string, index: bigint) => string;
-export declare const buildDbKeyForLeafIndex: (name: string, key: bigint) => string;
+export declare const buildDbKeyForPreimage: (name: string, index: bigint) => `${string}:leaf_by_index:${string}`;
+export declare const buildDbKeyForLeafIndex: (name: string, key: bigint) => `${string}:leaf_index_by_leaf_key:${string}`;
 /**
  * Factory for creating leaves.
  */
@@ -58,7 +33,9 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
     protected cachedLeafPreimages: {
         [key: string]: IndexedTreeLeafPreimage;
     };
-    constructor(db: LevelUp, hasher: Hasher, name: string, depth: number, size: bigint | undefined, leafPreimageFactory: PreimageFactory, leafFactory: LeafFactory, root?: Buffer);
+    protected leaves: AztecMap<ReturnType<typeof buildDbKeyForPreimage>, Buffer>;
+    protected leafIndex: AztecMap<ReturnType<typeof buildDbKeyForLeafIndex>, bigint>;
+    constructor(store: AztecKVStore, hasher: Hasher, name: string, depth: number, size: bigint | undefined, leafPreimageFactory: PreimageFactory, leafFactory: LeafFactory, root?: Buffer);
     /**
      * Appends the given leaves to the tree.
      * @param _leaves - The leaves to append.
@@ -82,14 +59,14 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
      * @param includeUncommitted - Indicates whether to include uncommitted leaves in the computation.
      * @returns The value of the leaf at the given index or undefined if the leaf is empty.
      */
-    getLeafValue(index: bigint, includeUncommitted: boolean): Promise<Buffer | undefined>;
+    getLeafValue(index: bigint, includeUncommitted: boolean): Buffer | undefined;
     /**
      * Finds the index of the largest leaf whose value is less than or equal to the provided value.
      * @param newKey - The new key 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`.
      */
-    findIndexOfPreviousKey(newKey: bigint, includeUncommitted: boolean): Promise<{
+    findIndexOfPreviousKey(newKey: bigint, includeUncommitted: boolean): {
         /**
          * The index of the found leaf.
          */
@@ -98,7 +75,7 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
          * A flag indicating if the corresponding leaf's value is equal to `newValue`.
          */
         alreadyPresent: boolean;
-    } | undefined>;
+    } | undefined;
     private getCachedLowLeafIndex;
     private getCachedLeafIndex;
     private getDbLowLeafIndex;
@@ -110,14 +87,14 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
      * @param includeUncommitted - If true, the uncommitted changes are included in the search.
      * @returns A copy of the leaf preimage at the given index or undefined if the leaf was not found.
      */
-    getLatestLeafPreimageCopy(index: bigint, includeUncommitted: boolean): Promise<IndexedTreeLeafPreimage | undefined>;
+    getLatestLeafPreimageCopy(index: bigint, includeUncommitted: boolean): IndexedTreeLeafPreimage | undefined;
     /**
      * 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).
      */
-    findLeafIndex(value: Buffer, includeUncommitted: boolean): Promise<bigint | undefined>;
+    findLeafIndex(value: Buffer, includeUncommitted: boolean): bigint | undefined;
     /**
      * Initializes the tree.
      * @param prefilledSize - A number of leaves that are prefilled with values.
@@ -146,7 +123,7 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
      * @param preimage - New contents of the leaf.
      * @param index - Index of the leaf to be updated.
      */
-    protected updateLeaf(preimage: IndexedTreeLeafPreimage, index: bigint): Promise<void>;
+    protected updateLeaf(preimage: IndexedTreeLeafPreimage, index: bigint): void;
     /**
      *
      * Each base rollup needs to provide non membership / inclusion proofs for each of the nullifier.
@@ -289,7 +266,7 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
     batchInsert<TreeHeight extends number, SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(leaves: Buffer[], subtreeHeight: SubtreeHeight): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>>;
     getSubtreeSiblingPath<SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(subtreeHeight: SubtreeHeight, includeUncommitted: boolean): Promise<SiblingPath<SubtreeSiblingPathHeight>>;
     snapshot(blockNumber: number): Promise<IndexedTreeSnapshot>;
-    getSnapshot(block: number): Promise<IndexedTreeSnapshot>;
+    getSnapshot(blockNumber: number): Promise<IndexedTreeSnapshot>;
     /**
      * Encodes leaves and appends them to a tree.
      * @param preimages - Leaves to encode.

package/dest/standard_indexed_tree/standard_indexed_tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standard_indexed_tree.d.ts","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"standard_indexed_tree.d.ts","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":"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"}

package/dest/standard_indexed_tree/standard_indexed_tree.js

@@ -1,12 +1,10 @@
 var _StandardIndexedTree_snapshotBuilder;
 import { __classPrivateFieldGet } from "tslib";
-import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Timer } from '@aztec/foundation/timer';
 import { SiblingPath } from '@aztec/types/membership';
-import { IndexedTreeSnapshotBuilder, } from '../index.js';
+import { IndexedTreeSnapshotBuilder } from '../snapshots/indexed_tree_snapshot.js';
 import { TreeBase } from '../tree_base.js';
-const log = createDebugLogger('aztec:standard-indexed-tree');
 export const buildDbKeyForPreimage = (name, index) => {
     return `${name}:leaf_by_index:${toBufferBE(index, 32).toString('hex')}`;
 };
@@ -29,12 +27,14 @@ function getEmptyLowLeafWitness(treeHeight, leafPreimageFactory) {
  * Standard implementation of an indexed tree.
  */
 export class StandardIndexedTree extends TreeBase {
-    constructor(db, hasher, name, depth, size = 0n, leafPreimageFactory, leafFactory, root) {
-        super(db, hasher, name, depth, size, root);
+    constructor(store, hasher, name, depth, size = 0n, leafPreimageFactory, leafFactory, root) {
+        super(store, hasher, name, depth, size, root);
         this.leafPreimageFactory = leafPreimageFactory;
         this.leafFactory = leafFactory;
-        _StandardIndexedTree_snapshotBuilder.set(this, new IndexedTreeSnapshotBuilder(this.db, this, this.leafPreimageFactory));
+        _StandardIndexedTree_snapshotBuilder.set(this, new IndexedTreeSnapshotBuilder(this.store, this, this.leafPreimageFactory));
         this.cachedLeafPreimages = {};
+        this.leaves = store.openMap(`tree_${name}_leaves`);
+        this.leafIndex = store.openMap(`tree_${name}_leaf_index`);
     }
     /**
      * Appends the given leaves to the tree.
@@ -67,8 +67,8 @@ export class StandardIndexedTree extends TreeBase {
      * @param includeUncommitted - Indicates whether to include uncommitted leaves in the computation.
      * @returns The value of the leaf at the given index or undefined if the leaf is empty.
      */
-    async getLeafValue(index, includeUncommitted) {
-        const preimage = await this.getLatestLeafPreimageCopy(index, includeUncommitted);
+    getLeafValue(index, includeUncommitted) {
+        const preimage = this.getLatestLeafPreimageCopy(index, includeUncommitted);
         return preimage && preimage.toBuffer();
     }
     /**
@@ -77,9 +77,9 @@ export class StandardIndexedTree extends TreeBase {
      * @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`.
      */
-    async findIndexOfPreviousKey(newKey, includeUncommitted) {
-        let lowLeafIndex = await this.getDbLowLeafIndex(newKey);
-        let lowLeafPreimage = lowLeafIndex !== undefined ? await this.getDbPreimage(lowLeafIndex) : undefined;
+    findIndexOfPreviousKey(newKey, includeUncommitted) {
+        let lowLeafIndex = this.getDbLowLeafIndex(newKey);
+        let lowLeafPreimage = lowLeafIndex !== undefined ? this.getDbPreimage(lowLeafIndex) : undefined;
         if (includeUncommitted) {
             const cachedLowLeafIndex = this.getCachedLowLeafIndex(newKey);
             if (cachedLowLeafIndex !== undefined) {
@@ -118,35 +118,17 @@ export class StandardIndexedTree extends TreeBase {
         }
         return undefined;
     }
-    async getDbLowLeafIndex(key) {
-        return await new Promise((resolve, reject) => {
-            let lowLeafIndex;
-            this.db
-                .createReadStream({
-                gte: buildDbKeyForLeafIndex(this.getName(), 0n),
-                lte: buildDbKeyForLeafIndex(this.getName(), key),
-                limit: 1,
-                reverse: true,
-            })
-                .on('data', data => {
-                lowLeafIndex = toBigIntBE(data.value);
-            })
-                .on('close', function () { })
-                .on('end', function () {
-                resolve(lowLeafIndex);
-            })
-                .on('error', function () {
-                log.error('stream error');
-                reject();
-            });
-        });
+    getDbLowLeafIndex(key) {
+        const values = Array.from(this.leafIndex.values({
+            end: buildDbKeyForLeafIndex(this.getName(), key),
+            limit: 1,
+            reverse: true,
+        }));
+        return values[0];
     }
-    async getDbPreimage(index) {
-        const dbPreimage = await this.db
-            .get(buildDbKeyForPreimage(this.getName(), index))
-            .then(data => this.leafPreimageFactory.fromBuffer(data))
-            .catch(() => undefined);
-        return dbPreimage;
+    getDbPreimage(index) {
+        const value = this.leaves.get(buildDbKeyForPreimage(this.getName(), index));
+        return value ? this.leafPreimageFactory.fromBuffer(value) : undefined;
     }
     getCachedPreimage(index) {
         return this.cachedLeafPreimages[index.toString()];
@@ -157,10 +139,10 @@ export class StandardIndexedTree extends TreeBase {
      * @param includeUncommitted - If true, the uncommitted changes are included in the search.
      * @returns A copy of the leaf preimage at the given index or undefined if the leaf was not found.
      */
-    async getLatestLeafPreimageCopy(index, includeUncommitted) {
+    getLatestLeafPreimageCopy(index, includeUncommitted) {
         const preimage = !includeUncommitted
-            ? await this.getDbPreimage(index)
-            : this.getCachedPreimage(index) ?? (await this.getDbPreimage(index));
+            ? this.getDbPreimage(index)
+            : this.getCachedPreimage(index) ?? this.getDbPreimage(index);
         return preimage && this.leafPreimageFactory.clone(preimage);
     }
     /**
@@ -169,12 +151,9 @@ export class StandardIndexedTree extends TreeBase {
      * @param includeUncommitted - Indicates whether to include uncommitted data.
      * @returns The index of the first leaf found with a given value (undefined if not found).
      */
-    async findLeafIndex(value, includeUncommitted) {
+    findLeafIndex(value, includeUncommitted) {
         const leaf = this.leafFactory.fromBuffer(value);
-        let index = await this.db
-            .get(buildDbKeyForLeafIndex(this.getName(), leaf.getKey()))
-            .then(data => toBigIntBE(data))
-            .catch(() => undefined);
+        let index = this.leafIndex.get(buildDbKeyForLeafIndex(this.getName(), leaf.getKey()));
         if (includeUncommitted && index === undefined) {
             const cachedIndex = this.getCachedLeafIndex(leaf.getKey());
             index = cachedIndex;
@@ -207,23 +186,23 @@ export class StandardIndexedTree extends TreeBase {
         }
         // Make the last leaf point to the first leaf
         leaves[prefilledSize - 1] = this.leafPreimageFactory.fromLeaf(leaves[prefilledSize - 1].asLeaf(), 0n, 0n);
-        await this.encodeAndAppendLeaves(leaves, true);
+        this.encodeAndAppendLeaves(leaves, true);
         await this.commit();
     }
     /**
      * Commits all the leaves to the database and removes them from a cache.
      */
-    async commitLeaves() {
-        const batch = this.db.batch();
-        const keys = Object.getOwnPropertyNames(this.cachedLeafPreimages);
-        for (const key of keys) {
-            const leaf = this.cachedLeafPreimages[key];
-            const index = BigInt(key);
-            batch.put(buildDbKeyForPreimage(this.getName(), index), leaf.toBuffer());
-            batch.put(buildDbKeyForLeafIndex(this.getName(), leaf.getKey()), toBufferBE(index, 32));
-        }
-        await batch.write();
-        this.clearCachedLeaves();
+    commitLeaves() {
+        return this.store.transaction(() => {
+            const keys = Object.getOwnPropertyNames(this.cachedLeafPreimages);
+            for (const key of keys) {
+                const leaf = this.cachedLeafPreimages[key];
+                const index = BigInt(key);
+                void this.leaves.set(buildDbKeyForPreimage(this.getName(), index), leaf.toBuffer());
+                void this.leafIndex.set(buildDbKeyForLeafIndex(this.getName(), leaf.getKey()), index);
+            }
+            this.clearCachedLeaves();
+        });
     }
     /**
      * Clears the cache.
@@ -236,13 +215,13 @@ export class StandardIndexedTree extends TreeBase {
      * @param preimage - New contents of the leaf.
      * @param index - Index of the leaf to be updated.
      */
-    async updateLeaf(preimage, index) {
+    updateLeaf(preimage, index) {
         if (index > this.maxIndex) {
             throw Error(`Index out of bounds. Index ${index}, max index: ${this.maxIndex}.`);
         }
         this.cachedLeafPreimages[index.toString()] = preimage;
         const encodedLeaf = this.encodeLeaf(preimage, true);
-        await this.addLeafToCacheAndHashToRoot(encodedLeaf, index);
+        this.addLeafToCacheAndHashToRoot(encodedLeaf, index);
         const numLeaves = this.getNumLeaves(true);
         if (index >= numLeaves) {
             this.cachedSize = index + 1n;
@@ -417,7 +396,7 @@ export class StandardIndexedTree extends TreeBase {
             else {
                 insertedKeys.set(newLeaf.getKey(), true);
             }
-            const indexOfPrevious = await this.findIndexOfPreviousKey(newLeaf.getKey(), true);
+            const indexOfPrevious = this.findIndexOfPreviousKey(newLeaf.getKey(), true);
             if (indexOfPrevious === undefined) {
                 return {
                     lowLeavesWitnessData: undefined,
@@ -428,7 +407,7 @@ export class StandardIndexedTree extends TreeBase {
             }
             const isUpdate = indexOfPrevious.alreadyPresent;
             // get the low leaf (existence checked in getting index)
-            const lowLeafPreimage = (await this.getLatestLeafPreimageCopy(indexOfPrevious.index, true));
+            const lowLeafPreimage = this.getLatestLeafPreimageCopy(indexOfPrevious.index, true);
             const siblingPath = await this.getSiblingPath(BigInt(indexOfPrevious.index), true);
             const witness = {
                 leafPreimage: lowLeafPreimage,
@@ -440,12 +419,12 @@ export class StandardIndexedTree extends TreeBase {
             if (isUpdate) {
                 const newLowLeaf = lowLeafPreimage.asLeaf().updateTo(newLeaf);
                 const newLowLeafPreimage = this.leafPreimageFactory.fromLeaf(newLowLeaf, lowLeafPreimage.getNextKey(), lowLeafPreimage.getNextIndex());
-                await this.updateLeaf(newLowLeafPreimage, indexOfPrevious.index);
+                this.updateLeaf(newLowLeafPreimage, indexOfPrevious.index);
                 pendingInsertionSubtree[originalIndex] = this.leafPreimageFactory.empty();
             }
             else {
                 const newLowLeafPreimage = this.leafPreimageFactory.fromLeaf(lowLeafPreimage.asLeaf(), newLeaf.getKey(), startInsertionIndex + BigInt(originalIndex));
-                await this.updateLeaf(newLowLeafPreimage, indexOfPrevious.index);
+                this.updateLeaf(newLowLeafPreimage, indexOfPrevious.index);
                 const currentPendingPreimageLeaf = this.leafPreimageFactory.fromLeaf(newLeaf, lowLeafPreimage.getNextKey(), lowLeafPreimage.getNextIndex());
                 pendingInsertionSubtree[originalIndex] = currentPendingPreimageLeaf;
             }
@@ -454,7 +433,7 @@ export class StandardIndexedTree extends TreeBase {
         // Perform batch insertion of new pending values
         // Note: In this case we set `hash0Leaf` param to false because batch insertion algorithm use forced null leaf
         // inclusion. See {@link encodeLeaf} for  a more through param explanation.
-        await this.encodeAndAppendLeaves(pendingInsertionSubtree, false);
+        this.encodeAndAppendLeaves(pendingInsertionSubtree, false);
         this.log(`Inserted ${leaves.length} leaves into ${this.getName()} tree`, {
             eventName: 'tree-insertion',
             duration: timer.ms(),
@@ -480,8 +459,8 @@ export class StandardIndexedTree extends TreeBase {
     snapshot(blockNumber) {
         return __classPrivateFieldGet(this, _StandardIndexedTree_snapshotBuilder, "f").snapshot(blockNumber);
     }
-    getSnapshot(block) {
-        return __classPrivateFieldGet(this, _StandardIndexedTree_snapshotBuilder, "f").getSnapshot(block);
+    getSnapshot(blockNumber) {
+        return __classPrivateFieldGet(this, _StandardIndexedTree_snapshotBuilder, "f").getSnapshot(blockNumber);
     }
     /**
      * Encodes leaves and appends them to a tree.
@@ -489,13 +468,13 @@ export class StandardIndexedTree extends TreeBase {
      * @param hash0Leaf - Indicates whether 0 value leaf should be hashed. See {@link encodeLeaf}.
      * @returns Empty promise
      */
-    async encodeAndAppendLeaves(preimages, hash0Leaf) {
+    encodeAndAppendLeaves(preimages, hash0Leaf) {
         const startInsertionIndex = this.getNumLeaves(true);
         const hashedLeaves = preimages.map((preimage, i) => {
             this.cachedLeafPreimages[(startInsertionIndex + BigInt(i)).toString()] = preimage;
             return this.encodeLeaf(preimage, hash0Leaf);
         });
-        await super.appendLeaves(hashedLeaves);
+        super.appendLeaves(hashedLeaves);
     }
     /**
      * Encode a leaf into a buffer.
@@ -517,4 +496,4 @@ export class StandardIndexedTree extends TreeBase {
     }
 }
 _StandardIndexedTree_snapshotBuilder = new WeakMap();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard_indexed_tree.js","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard_indexed_tree.js","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":"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"}

package/dest/standard_indexed_tree/test/standard_indexed_tree_with_append.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standard_indexed_tree_with_append.d.ts","sourceRoot":"","sources":["../../../src/standard_indexed_tree/test/standard_indexed_tree_with_append.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;;GAIG;AACH,qBAAa,6BAA8B,SAAQ,mBAAmB;IACpE;;;;;OAKG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1D,OAAO,CAAC,eAAe;IAQvB;;;;OAIG;YACW,UAAU;CA6CzB"}
+{"version":3,"file":"standard_indexed_tree_with_append.d.ts","sourceRoot":"","sources":["../../../src/standard_indexed_tree/test/standard_indexed_tree_with_append.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;;GAIG;AACH,qBAAa,6BAA8B,SAAQ,mBAAmB;IACpE;;;;;OAKG;IACI,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpD,OAAO,CAAC,eAAe;IAQvB;;;;OAIG;IACH,OAAO,CAAC,UAAU;CA6CnB"}

package/dest/standard_indexed_tree/test/standard_indexed_tree_with_append.js

@@ -11,10 +11,11 @@ export class StandardIndexedTreeWithAppend extends StandardIndexedTree {
      * @returns Empty promise.
      * @remarks This method is inefficient and is here mostly for testing. Use batchInsert instead.
      */
-    async appendLeaves(leaves) {
+    appendLeaves(leaves) {
         for (const leaf of leaves) {
-            await this.appendLeaf(leaf);
+            this.appendLeaf(leaf);
         }
+        return Promise.resolve();
     }
     appendEmptyLeaf() {
         const newSize = (this.cachedSize ?? this.size) + 1n;
@@ -28,33 +29,33 @@ export class StandardIndexedTreeWithAppend extends StandardIndexedTree {
      * @param leaf - The leaf to append.
      * @returns Empty promise.
      */
-    async appendLeaf(leaf) {
+    appendLeaf(leaf) {
         const newLeaf = this.leafFactory.fromBuffer(leaf);
         // Special case when appending zero
         if (newLeaf.getKey() === 0n) {
             this.appendEmptyLeaf();
             return;
         }
-        const lowLeafIndex = await this.findIndexOfPreviousKey(newLeaf.getKey(), true);
+        const lowLeafIndex = this.findIndexOfPreviousKey(newLeaf.getKey(), true);
         if (lowLeafIndex === undefined) {
             throw new Error(`Previous leaf not found!`);
         }
         const isUpdate = lowLeafIndex.alreadyPresent;
-        const lowLeafPreimage = (await this.getLatestLeafPreimageCopy(lowLeafIndex.index, true));
+        const lowLeafPreimage = this.getLatestLeafPreimageCopy(lowLeafIndex.index, true);
         const currentSize = this.getNumLeaves(true);
         if (isUpdate) {
             const newLowLeaf = lowLeafPreimage.asLeaf().updateTo(newLeaf);
             const newLowLeafPreimage = this.leafPreimageFactory.fromLeaf(newLowLeaf, lowLeafPreimage.getNextKey(), lowLeafPreimage.getNextIndex());
-            await this.updateLeaf(newLowLeafPreimage, BigInt(lowLeafIndex.index));
+            this.updateLeaf(newLowLeafPreimage, BigInt(lowLeafIndex.index));
             this.appendEmptyLeaf();
         }
         else {
             const newLeafPreimage = this.leafPreimageFactory.fromLeaf(newLeaf, lowLeafPreimage.getNextKey(), lowLeafPreimage.getNextIndex());
             // insert a new leaf at the highest index and update the values of our previous leaf copy
             const newLowLeafPreimage = this.leafPreimageFactory.fromLeaf(lowLeafPreimage.asLeaf(), newLeaf.getKey(), BigInt(currentSize));
-            await this.updateLeaf(newLowLeafPreimage, BigInt(lowLeafIndex.index));
-            await this.updateLeaf(newLeafPreimage, currentSize);
+            this.updateLeaf(newLowLeafPreimage, BigInt(lowLeafIndex.index));
+            this.updateLeaf(newLeafPreimage, currentSize);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/standard_tree/standard_tree.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
-import { TreeSnapshot } from '../index.js';
 import { AppendOnlyTree } from '../interfaces/append_only_tree.js';
+import { TreeSnapshot } from '../snapshots/snapshot_builder.js';
 import { TreeBase } from '../tree_base.js';
 /**
  * A Merkle tree implementation that uses a LevelDB database to store the tree.
@@ -13,8 +13,8 @@ export declare class StandardTree extends TreeBase implements AppendOnlyTree {
      * @returns Empty promise.
      */
     appendLeaves(leaves: Buffer[]): Promise<void>;
-    snapshot(block: number): Promise<TreeSnapshot>;
-    getSnapshot(block: number): Promise<TreeSnapshot>;
-    findLeafIndex(value: Buffer, includeUncommitted: boolean): Promise<bigint | undefined>;
+    snapshot(blockNumber: number): Promise<TreeSnapshot>;
+    getSnapshot(blockNumber: number): Promise<TreeSnapshot>;
+    findLeafIndex(value: Buffer, includeUncommitted: boolean): bigint | undefined;
 }
 //# sourceMappingURL=standard_tree.d.ts.map

package/dest/standard_tree/standard_tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standard_tree.d.ts","sourceRoot":"","sources":["../../src/standard_tree/standard_tree.ts"],"names":[],"mappings":";AAGA,OAAO,EAA6B,YAAY,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;GAEG;AACH,qBAAa,YAAa,SAAQ,QAAS,YAAW,cAAc;;IAGlE;;;;OAIG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAenD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAI9C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAI3C,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;CASpG"}
+{"version":3,"file":"standard_tree.d.ts","sourceRoot":"","sources":["../../src/standard_tree/standard_tree.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;GAEG;AACH,qBAAa,YAAa,SAAQ,QAAS,YAAW,cAAc;;IAGlE;;;;OAIG;IACI,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB7C,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAIpD,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAIvD,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;CASrF"}

package/dest/standard_tree/standard_tree.js

@@ -1,7 +1,7 @@
 var _StandardTree_snapshotBuilder;
 import { __classPrivateFieldGet } from "tslib";
 import { Timer } from '@aztec/foundation/timer';
-import { AppendOnlySnapshotBuilder } from '../index.js';
+import { AppendOnlySnapshotBuilder } from '../snapshots/append_only_snapshot.js';
 import { TreeBase } from '../tree_base.js';
 /**
  * A Merkle tree implementation that uses a LevelDB database to store the tree.
@@ -9,17 +9,17 @@ import { TreeBase } from '../tree_base.js';
 export class StandardTree extends TreeBase {
     constructor() {
         super(...arguments);
-        _StandardTree_snapshotBuilder.set(this, new AppendOnlySnapshotBuilder(this.db, this, this.hasher));
+        _StandardTree_snapshotBuilder.set(this, new AppendOnlySnapshotBuilder(this.store, this, this.hasher));
     }
     /**
      * Appends the given leaves to the tree.
      * @param leaves - The leaves to append.
      * @returns Empty promise.
      */
-    async appendLeaves(leaves) {
+    appendLeaves(leaves) {
         this.hasher.reset();
         const timer = new Timer();
-        await super.appendLeaves(leaves);
+        super.appendLeaves(leaves);
         this.log(`Inserted ${leaves.length} leaves into ${this.getName()} tree`, {
             eventName: 'tree-insertion',
             duration: timer.ms(),
@@ -29,16 +29,17 @@ export class StandardTree extends TreeBase {
             treeType: 'append-only',
             ...this.hasher.stats(),
         });
+        return Promise.resolve();
     }
-    snapshot(block) {
-        return __classPrivateFieldGet(this, _StandardTree_snapshotBuilder, "f").snapshot(block);
+    snapshot(blockNumber) {
+        return __classPrivateFieldGet(this, _StandardTree_snapshotBuilder, "f").snapshot(blockNumber);
     }
-    getSnapshot(block) {
-        return __classPrivateFieldGet(this, _StandardTree_snapshotBuilder, "f").getSnapshot(block);
+    getSnapshot(blockNumber) {
+        return __classPrivateFieldGet(this, _StandardTree_snapshotBuilder, "f").getSnapshot(blockNumber);
     }
-    async findLeafIndex(value, includeUncommitted) {
+    findLeafIndex(value, includeUncommitted) {
         for (let i = 0n; i < this.getNumLeaves(includeUncommitted); i++) {
-            const currentValue = await this.getLeafValue(i, includeUncommitted);
+            const currentValue = this.getLeafValue(i, includeUncommitted);
             if (currentValue && currentValue.equals(value)) {
                 return i;
             }
@@ -47,4 +48,4 @@ export class StandardTree extends TreeBase {
     }
 }
 _StandardTree_snapshotBuilder = new WeakMap();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfdHJlZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGFuZGFyZF90cmVlL3N0YW5kYXJkX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFDQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFaEQsT0FBTyxFQUFFLHlCQUF5QixFQUFnQixNQUFNLGFBQWEsQ0FBQztBQUV0RSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFM0M7O0dBRUc7QUFDSCxNQUFNLE9BQU8sWUFBYSxTQUFRLFFBQVE7SUFBMUM7O1FBQ0Usd0NBQW1CLElBQUkseUJBQXlCLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFDO0lBdUMvRSxDQUFDO0lBckNDOzs7O09BSUc7SUFDSSxLQUFLLENBQUMsWUFBWSxDQUFDLE1BQWdCO1FBQ3hDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDcEIsTUFBTSxLQUFLLEdBQUcsSUFBSSxLQUFLLEVBQUUsQ0FBQztRQUMxQixNQUFNLEtBQUssQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDakMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxZQUFZLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixJQUFJLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRTtZQUN2RSxTQUFTLEVBQUUsZ0JBQWdCO1lBQzNCLFFBQVEsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFO1lBQ3BCLFNBQVMsRUFBRSxNQUFNLENBQUMsTUFBTTtZQUN4QixRQUFRLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBRTtZQUN4QixTQUFTLEVBQUUsSUFBSSxDQUFDLFFBQVEsRUFBRTtZQUMxQixRQUFRLEVBQUUsYUFBYTtZQUN2QixHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFO1NBQ00sQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFTSxRQUFRLENBQUMsS0FBYTtRQUMzQixPQUFPLHVCQUFBLElBQUkscUNBQWlCLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQy9DLENBQUM7SUFFTSxXQUFXLENBQUMsS0FBYTtRQUM5QixPQUFPLHVCQUFBLElBQUkscUNBQWlCLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFTSxLQUFLLENBQUMsYUFBYSxDQUFDLEtBQWEsRUFBRSxrQkFBMkI7UUFDbkUsS0FBSyxJQUFJLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsa0JBQWtCLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRTtZQUMvRCxNQUFNLFlBQVksR0FBRyxNQUFNLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxFQUFFLGtCQUFrQixDQUFDLENBQUM7WUFDcEUsSUFBSSxZQUFZLElBQUksWUFBWSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRTtnQkFDOUMsT0FBTyxDQUFDLENBQUM7YUFDVjtTQUNGO1FBQ0QsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfdHJlZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGFuZGFyZF90cmVlL3N0YW5kYXJkX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFDQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHaEQsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFFakYsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTNDOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFlBQWEsU0FBUSxRQUFRO0lBQTFDOztRQUNFLHdDQUFtQixJQUFJLHlCQUF5QixDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBQztJQXlDbEYsQ0FBQztJQXZDQzs7OztPQUlHO0lBQ0ksWUFBWSxDQUFDLE1BQWdCO1FBQ2xDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDcEIsTUFBTSxLQUFLLEdBQUcsSUFBSSxLQUFLLEVBQUUsQ0FBQztRQUMxQixLQUFLLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzNCLElBQUksQ0FBQyxHQUFHLENBQUMsWUFBWSxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsSUFBSSxDQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUU7WUFDdkUsU0FBUyxFQUFFLGdCQUFnQjtZQUMzQixRQUFRLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRTtZQUNwQixTQUFTLEVBQUUsTUFBTSxDQUFDLE1BQU07WUFDeEIsUUFBUSxFQUFFLElBQUksQ0FBQyxPQUFPLEVBQUU7WUFDeEIsU0FBUyxFQUFFLElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDMUIsUUFBUSxFQUFFLGFBQWE7WUFDdkIsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRTtTQUNNLENBQUMsQ0FBQztRQUVoQyxPQUFPLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRU0sUUFBUSxDQUFDLFdBQW1CO1FBQ2pDLE9BQU8sdUJBQUEsSUFBSSxxQ0FBaUIsQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckQsQ0FBQztJQUVNLFdBQVcsQ0FBQyxXQUFtQjtRQUNwQyxPQUFPLHVCQUFBLElBQUkscUNBQWlCLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFTSxhQUFhLENBQUMsS0FBYSxFQUFFLGtCQUEyQjtRQUM3RCxLQUFLLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7WUFDaEUsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLEVBQUUsa0JBQWtCLENBQUMsQ0FBQztZQUM5RCxJQUFJLFlBQVksSUFBSSxZQUFZLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQy9DLE9BQU8sQ0FBQyxDQUFDO1lBQ1gsQ0FBQztRQUNILENBQUM7UUFDRCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0NBQ0YifQ==