@aztec/merkle-tree 0.16.1 → 0.16.2

package/dest/snapshots/base_full_snapshot.js

@@ -0,0 +1,179 @@
+var _BaseFullTreeSnapshotBuilder_instances, _BaseFullTreeSnapshotBuilder_getSnapshotMeta, _BaseFullTreeSnapshot_instances, _BaseFullTreeSnapshot_getPathFromRoot;
+import { __classPrivateFieldGet } from "tslib";
+import { SiblingPath } from '@aztec/types';
+// key for a node's children
+const snapshotChildKey = (node, child) => Buffer.concat([Buffer.from('snapshot:node:'), node, Buffer.from(':' + child)]);
+// metadata for a snapshot
+const snapshotRootKey = (treeName, block) => `snapshot:root:${treeName}:${block}`;
+const snapshotNumLeavesKey = (treeName, block) => `snapshot:numLeaves:${treeName}:${block}`;
+/**
+ * Builds a full snapshot of a tree. This implementation works for any Merkle tree and stores
+ * it in a database in a similar way to how a tree is stored in memory, using pointers.
+ *
+ * Sharing the same database between versions and trees is recommended as the trees would share
+ * structure.
+ *
+ * Implement the protected method `handleLeaf` to store any additional data you need for each leaf.
+ *
+ * Complexity:
+ * N - count of non-zero nodes in tree
+ * M - count of snapshots
+ * H - tree height
+ * Worst case space complexity: O(N * M)
+ * Sibling path access: O(H) database reads
+ */
+export class BaseFullTreeSnapshotBuilder {
+    constructor(db, tree) {
+        _BaseFullTreeSnapshotBuilder_instances.add(this);
+        this.db = db;
+        this.tree = tree;
+    }
+    async snapshot(block) {
+        const snapshotMetadata = await __classPrivateFieldGet(this, _BaseFullTreeSnapshotBuilder_instances, "m", _BaseFullTreeSnapshotBuilder_getSnapshotMeta).call(this, block);
+        if (snapshotMetadata) {
+            return this.openSnapshot(snapshotMetadata.root, snapshotMetadata.numLeaves);
+        }
+        const batch = this.db.batch();
+        const root = this.tree.getRoot(false);
+        const numLeaves = this.tree.getNumLeaves(false);
+        const depth = this.tree.getDepth();
+        const queue = [[root, 0, 0n]];
+        // walk the tree breadth-first and store each of its nodes in the database
+        // for each node we save two keys
+        //   <node hash>:0 -> <left child's hash>
+        //   <node hash>:1 -> <right child's hash>
+        while (queue.length > 0) {
+            const [node, level, i] = queue.shift();
+            // check if the database already has a child for this tree
+            // if it does, then we know we've seen the whole subtree below it before
+            // and we don't have to traverse it anymore
+            // we use the left child here, but it could be anything that shows we've stored the node before
+            const exists = await this.db.get(snapshotChildKey(node, 0)).catch(() => undefined);
+            if (exists) {
+                continue;
+            }
+            if (level + 1 > depth) {
+                // short circuit if we've reached the leaf level
+                // otherwise getNode might throw if we ask for the children of a leaf
+                await this.handleLeaf(i, node, batch);
+                continue;
+            }
+            const [lhs, rhs] = await Promise.all([
+                this.tree.getNode(level + 1, 2n * i),
+                this.tree.getNode(level + 1, 2n * i + 1n),
+            ]);
+            // we want the zero hash at the children's level, not the node's level
+            const zeroHash = this.tree.getZeroHash(level + 1);
+            batch.put(snapshotChildKey(node, 0), lhs ?? zeroHash);
+            batch.put(snapshotChildKey(node, 1), rhs ?? zeroHash);
+            // enqueue the children only if they're not zero hashes
+            if (lhs) {
+                queue.push([lhs, level + 1, 2n * i]);
+            }
+            if (rhs) {
+                queue.push([rhs, level + 1, 2n * i + 1n]);
+            }
+        }
+        batch.put(snapshotRootKey(this.tree.getName(), block), root);
+        batch.put(snapshotNumLeavesKey(this.tree.getName(), block), String(numLeaves));
+        await batch.write();
+        return this.openSnapshot(root, numLeaves);
+    }
+    handleLeaf(_index, _node, _batch) {
+        return Promise.resolve();
+    }
+    async getSnapshot(version) {
+        const snapshotMetadata = await __classPrivateFieldGet(this, _BaseFullTreeSnapshotBuilder_instances, "m", _BaseFullTreeSnapshotBuilder_getSnapshotMeta).call(this, version);
+        if (!snapshotMetadata) {
+            throw new Error(`Version ${version} does not exist for tree ${this.tree.getName()}`);
+        }
+        return this.openSnapshot(snapshotMetadata.root, snapshotMetadata.numLeaves);
+    }
+}
+_BaseFullTreeSnapshotBuilder_instances = new WeakSet(), _BaseFullTreeSnapshotBuilder_getSnapshotMeta = async function _BaseFullTreeSnapshotBuilder_getSnapshotMeta(block) {
+    try {
+        const treeName = this.tree.getName();
+        const root = await this.db.get(snapshotRootKey(treeName, block));
+        const numLeaves = BigInt(await this.db.get(snapshotNumLeavesKey(treeName, block)));
+        return { root, numLeaves };
+    }
+    catch (err) {
+        return undefined;
+    }
+};
+/**
+ * A source of sibling paths from a snapshot tree
+ */
+export class BaseFullTreeSnapshot {
+    constructor(db, historicRoot, numLeaves, tree) {
+        _BaseFullTreeSnapshot_instances.add(this);
+        this.db = db;
+        this.historicRoot = historicRoot;
+        this.numLeaves = numLeaves;
+        this.tree = tree;
+    }
+    async getSiblingPath(index) {
+        const siblings = [];
+        for await (const [_node, sibling] of this.pathFromRootToLeaf(index)) {
+            siblings.push(sibling);
+        }
+        // we got the siblings we were looking for, but they are in root-leaf order
+        // reverse them here so we have leaf-root (what SiblingPath expects)
+        siblings.reverse();
+        return new SiblingPath(this.tree.getDepth(), siblings);
+    }
+    async getLeafValue(index) {
+        let leafNode = undefined;
+        for await (const [node, _sibling] of this.pathFromRootToLeaf(index)) {
+            leafNode = node;
+        }
+        return leafNode;
+    }
+    getDepth() {
+        return this.tree.getDepth();
+    }
+    getRoot() {
+        return this.historicRoot;
+    }
+    getNumLeaves() {
+        return this.numLeaves;
+    }
+    async *pathFromRootToLeaf(leafIndex) {
+        const root = this.historicRoot;
+        const pathFromRoot = __classPrivateFieldGet(this, _BaseFullTreeSnapshot_instances, "m", _BaseFullTreeSnapshot_getPathFromRoot).call(this, leafIndex);
+        let node = root;
+        for (let i = 0; i < pathFromRoot.length; i++) {
+            // get both children. We'll need both anyway (one to keep track of, the other to walk down to)
+            const children = await Promise.all([
+                this.db.get(snapshotChildKey(node, 0)),
+                this.db.get(snapshotChildKey(node, 1)),
+            ]).catch(() => [this.tree.getZeroHash(i + 1), this.tree.getZeroHash(i + 1)]);
+            const next = children[pathFromRoot[i]];
+            const sibling = children[(pathFromRoot[i] + 1) % 2];
+            yield [next, sibling];
+            node = next;
+        }
+    }
+    async findLeafIndex(value) {
+        const numLeaves = this.getNumLeaves();
+        for (let i = 0n; i < numLeaves; i++) {
+            const currentValue = await this.getLeafValue(i);
+            if (currentValue && currentValue.equals(value)) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+}
+_BaseFullTreeSnapshot_instances = new WeakSet(), _BaseFullTreeSnapshot_getPathFromRoot = function _BaseFullTreeSnapshot_getPathFromRoot(leafIndex) {
+    const path = [];
+    let level = this.tree.getDepth();
+    while (level > 0) {
+        path.push(leafIndex & 0x01n ? 1 : 0);
+        leafIndex >>= 1n;
+        level--;
+    }
+    path.reverse();
+    return path;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base_full_snapshot.js","sourceRoot":"","sources":["../../src/snapshots/base_full_snapshot.ts"],"names":[],"mappings":"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"}

package/dest/snapshots/full_snapshot.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" resolution-mode="require"/>
+import { TreeBase } from '../tree_base.js';
+import { BaseFullTreeSnapshotBuilder } from './base_full_snapshot.js';
+import { TreeSnapshot, TreeSnapshotBuilder } from './snapshot_builder.js';
+/**
+ * Builds a full snapshot of a tree. This implementation works for any Merkle tree and stores
+ * it in a database in a similar way to how a tree is stored in memory, using pointers.
+ *
+ * Sharing the same database between versions and trees is recommended as the trees would share
+ * structure.
+ *
+ * Complexity:
+ * N - count of non-zero nodes in tree
+ * M - count of snapshots
+ * H - tree height
+ * Worst case space complexity: O(N * M)
+ * Sibling path access: O(H) database reads
+ */
+export declare class FullTreeSnapshotBuilder extends BaseFullTreeSnapshotBuilder<TreeBase, TreeSnapshot> implements TreeSnapshotBuilder<TreeSnapshot> {
+    protected openSnapshot(root: Buffer, numLeaves: bigint): TreeSnapshot;
+}
+//# sourceMappingURL=full_snapshot.d.ts.map

package/dest/snapshots/full_snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"full_snapshot.d.ts","sourceRoot":"","sources":["../../src/snapshots/full_snapshot.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAwB,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE1E;;;;;;;;;;;;;GAaG;AACH,qBAAa,uBACX,SAAQ,2BAA2B,CAAC,QAAQ,EAAE,YAAY,CAC1D,YAAW,mBAAmB,CAAC,YAAY,CAAC;IAE5C,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY;CAGtE"}

package/dest/snapshots/full_snapshot.js

@@ -0,0 +1,21 @@
+import { BaseFullTreeSnapshot, BaseFullTreeSnapshotBuilder } from './base_full_snapshot.js';
+/**
+ * Builds a full snapshot of a tree. This implementation works for any Merkle tree and stores
+ * it in a database in a similar way to how a tree is stored in memory, using pointers.
+ *
+ * Sharing the same database between versions and trees is recommended as the trees would share
+ * structure.
+ *
+ * Complexity:
+ * N - count of non-zero nodes in tree
+ * M - count of snapshots
+ * H - tree height
+ * Worst case space complexity: O(N * M)
+ * Sibling path access: O(H) database reads
+ */
+export class FullTreeSnapshotBuilder extends BaseFullTreeSnapshotBuilder {
+    openSnapshot(root, numLeaves) {
+        return new BaseFullTreeSnapshot(this.db, root, numLeaves, this.tree);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVsbF9zbmFwc2hvdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zbmFwc2hvdHMvZnVsbF9zbmFwc2hvdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUc1Rjs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsTUFBTSxPQUFPLHVCQUNYLFNBQVEsMkJBQW1EO0lBR2pELFlBQVksQ0FBQyxJQUFZLEVBQUUsU0FBaUI7UUFDcEQsT0FBTyxJQUFJLG9CQUFvQixDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDdkUsQ0FBQztDQUNGIn0=

package/dest/snapshots/indexed_tree_snapshot.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import { LevelUp, LevelUpChain } from 'levelup';
+import { IndexedTree } from '../interfaces/indexed_tree.js';
+import { PreimageFactory } from '../standard_indexed_tree/standard_indexed_tree.js';
+import { TreeBase } from '../tree_base.js';
+import { BaseFullTreeSnapshotBuilder } from './base_full_snapshot.js';
+import { IndexedTreeSnapshot, TreeSnapshotBuilder } from './snapshot_builder.js';
+/** a */
+export declare class IndexedTreeSnapshotBuilder extends BaseFullTreeSnapshotBuilder<IndexedTree & TreeBase, IndexedTreeSnapshot> implements TreeSnapshotBuilder<IndexedTreeSnapshot> {
+    private leafPreimageBuilder;
+    constructor(db: LevelUp, tree: IndexedTree & TreeBase, leafPreimageBuilder: PreimageFactory);
+    protected openSnapshot(root: Buffer, numLeaves: bigint): IndexedTreeSnapshot;
+    protected handleLeaf(index: bigint, node: Buffer, batch: LevelUpChain): Promise<void>;
+}
+//# sourceMappingURL=indexed_tree_snapshot.d.ts.map

package/dest/snapshots/indexed_tree_snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed_tree_snapshot.d.ts","sourceRoot":"","sources":["../../src/snapshots/indexed_tree_snapshot.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mDAAmD,CAAC;AACpF,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAwB,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC5F,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAKjF,QAAQ;AACR,qBAAa,0BACX,SAAQ,2BAA2B,CAAC,WAAW,GAAG,QAAQ,EAAE,mBAAmB,CAC/E,YAAW,mBAAmB,CAAC,mBAAmB,CAAC;IAEI,OAAO,CAAC,mBAAmB;gBAAtE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,EAAU,mBAAmB,EAAE,eAAe;IAInG,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,mBAAmB;cAI5D,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY;CAM5E"}

package/dest/snapshots/indexed_tree_snapshot.js

@@ -0,0 +1,75 @@
+import { BaseFullTreeSnapshot, BaseFullTreeSnapshotBuilder } from './base_full_snapshot.js';
+const snapshotLeafValue = (node, index) => Buffer.concat([Buffer.from('snapshot:leaf:'), node, Buffer.from(':' + index)]);
+/** a */
+export class IndexedTreeSnapshotBuilder extends BaseFullTreeSnapshotBuilder {
+    constructor(db, tree, leafPreimageBuilder) {
+        super(db, tree);
+        this.leafPreimageBuilder = leafPreimageBuilder;
+    }
+    openSnapshot(root, numLeaves) {
+        return new IndexedTreeSnapshotImpl(this.db, root, numLeaves, this.tree, this.leafPreimageBuilder);
+    }
+    async handleLeaf(index, node, batch) {
+        const leafPreimage = await this.tree.getLatestLeafPreimageCopy(index, false);
+        if (leafPreimage) {
+            batch.put(snapshotLeafValue(node, index), leafPreimage.toBuffer());
+        }
+    }
+}
+/** A snapshot of an indexed tree at a particular point in time */
+class IndexedTreeSnapshotImpl extends BaseFullTreeSnapshot {
+    constructor(db, historicRoot, numLeaves, tree, leafPreimageBuilder) {
+        super(db, historicRoot, numLeaves, tree);
+        this.leafPreimageBuilder = leafPreimageBuilder;
+    }
+    async getLeafValue(index) {
+        const leafPreimage = await this.getLatestLeafPreimageCopy(index);
+        return leafPreimage?.toBuffer();
+    }
+    async getLatestLeafPreimageCopy(index) {
+        const leafNode = await super.getLeafValue(index);
+        const leafValue = await this.db.get(snapshotLeafValue(leafNode, index)).catch(() => undefined);
+        if (leafValue) {
+            return this.leafPreimageBuilder.fromBuffer(leafValue);
+        }
+        else {
+            return undefined;
+        }
+    }
+    async findIndexOfPreviousKey(newValue) {
+        const numLeaves = this.getNumLeaves();
+        const diff = [];
+        for (let i = 0; i < numLeaves; i++) {
+            // this is very inefficient
+            const storedLeaf = await this.getLatestLeafPreimageCopy(BigInt(i));
+            // The stored leaf can be undefined if it addresses an empty leaf
+            // If the leaf is empty we do the same as if the leaf was larger
+            if (storedLeaf === undefined) {
+                diff.push(newValue);
+            }
+            else if (storedLeaf.getKey() > newValue) {
+                diff.push(newValue);
+            }
+            else if (storedLeaf.getKey() === newValue) {
+                return { index: BigInt(i), alreadyPresent: true };
+            }
+            else {
+                diff.push(newValue - storedLeaf.getKey());
+            }
+        }
+        let minIndex = 0;
+        for (let i = 1; i < diff.length; i++) {
+            if (diff[i] < diff[minIndex]) {
+                minIndex = i;
+            }
+        }
+        return { index: BigInt(minIndex), alreadyPresent: false };
+    }
+    async findLeafIndex(value) {
+        const index = await this.tree.findLeafIndex(value, false);
+        if (index !== undefined && index < this.getNumLeaves()) {
+            return index;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/snapshots/snapshot_builder.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" resolution-mode="require"/>
+import { IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+import { SiblingPath } from '@aztec/types';
+/**
+ * An interface for a tree that can record snapshots of its contents.
+ */
+export interface TreeSnapshotBuilder<S extends TreeSnapshot = TreeSnapshot> {
+    /**
+     * Creates a snapshot of the tree at the given version.
+     * @param block - The version to snapshot the tree at.
+     */
+    snapshot(block: number): Promise<S>;
+    /**
+     * Returns a snapshot of the tree at the given version.
+     * @param block - The version of the snapshot to return.
+     */
+    getSnapshot(block: number): Promise<S>;
+}
+/**
+ * A tree snapshot
+ */
+export interface TreeSnapshot {
+    /**
+     * Returns the current root of the tree.
+     */
+    getRoot(): Buffer;
+    /**
+     * Returns the number of leaves in the tree.
+     */
+    getDepth(): number;
+    /**
+     * Returns the number of leaves in the tree.
+     */
+    getNumLeaves(): bigint;
+    /**
+     * Returns the value of a leaf at the specified index.
+     * @param index - The index of the leaf value to be returned.
+     */
+    getLeafValue(index: bigint): Promise<Buffer | undefined>;
+    /**
+     * Returns the sibling path for a requested leaf index.
+     * @param index - The index of the leaf for which a sibling path is required.
+     */
+    getSiblingPath<N extends number>(index: bigint): Promise<SiblingPath<N>>;
+    /**
+     * 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(value: Buffer): Promise<bigint | undefined>;
+}
+/** A snapshot of an indexed tree */
+export interface IndexedTreeSnapshot extends TreeSnapshot {
+    /**
+     * Gets the historical data for a leaf
+     * @param index - The index of the leaf to get the data for
+     */
+    getLatestLeafPreimageCopy(index: bigint): Promise<IndexedTreeLeafPreimage | undefined>;
+    /**
+     * Finds the index of the largest leaf whose value is less than or equal to the provided value.
+     * @param newValue - The new value to be inserted into the tree.
+     * @returns The found leaf index and a flag indicating if the corresponding leaf's value is equal to `newValue`.
+     */
+    findIndexOfPreviousKey(newValue: 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;
+    }>;
+}
+//# sourceMappingURL=snapshot_builder.d.ts.map

package/dest/snapshots/snapshot_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot_builder.d.ts","sourceRoot":"","sources":["../../src/snapshots/snapshot_builder.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY;IACxE;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEpC;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,OAAO,IAAI,MAAM,CAAC;IAElB;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,IAAI,MAAM,CAAC;IAEvB;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAEzD;;;OAGG;IACH,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzE;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CAC3D;AAED,oCAAoC;AACpC,MAAM,WAAW,mBAAoB,SAAQ,YAAY;IACvD;;;OAGG;IACH,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAAC;IAEvF;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAChD;;WAEG;QACH,KAAK,EAAE,MAAM,CAAC;QACd;;WAEG;QACH,cAAc,EAAE,OAAO,CAAC;KACzB,CAAC,CAAC;CACJ"}

package/dest/snapshots/snapshot_builder.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hcHNob3RfYnVpbGRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zbmFwc2hvdHMvc25hcHNob3RfYnVpbGRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/snapshots/snapshot_builder_test_suite.d.ts

@@ -0,0 +1,5 @@
+import { TreeBase } from '../tree_base.js';
+import { TreeSnapshotBuilder } from './snapshot_builder.js';
+/** Creates a test suit for snapshots */
+export declare function describeSnapshotBuilderTestSuite<T extends TreeBase, S extends TreeSnapshotBuilder>(getTree: () => T, getSnapshotBuilder: () => S, modifyTree: (tree: T) => Promise<void>): void;
+//# sourceMappingURL=snapshot_builder_test_suite.d.ts.map

package/dest/snapshots/snapshot_builder_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot_builder_test_suite.d.ts","sourceRoot":"","sources":["../../src/snapshots/snapshot_builder_test_suite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,wCAAwC;AACxC,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,mBAAmB,EAChG,OAAO,EAAE,MAAM,CAAC,EAChB,kBAAkB,EAAE,MAAM,CAAC,EAC3B,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,QAkNvC"}

package/dest/snapshots/snapshot_builder_test_suite.js

@@ -0,0 +1,163 @@
+/** Creates a test suit for snapshots */
+export function describeSnapshotBuilderTestSuite(getTree, getSnapshotBuilder, modifyTree) {
+    describe('SnapshotBuilder', () => {
+        let tree;
+        let snapshotBuilder;
+        let leaves;
+        beforeEach(() => {
+            tree = getTree();
+            snapshotBuilder = getSnapshotBuilder();
+            leaves = Array.from({ length: 4 }).map(() => BigInt(Math.floor(Math.random() * 2 ** tree.getDepth())));
+        });
+        describe('snapshot', () => {
+            it('takes snapshots', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                await expect(snapshotBuilder.snapshot(1)).resolves.toBeDefined();
+            });
+            it('is idempotent', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const block = 1;
+                const snapshot = await snapshotBuilder.snapshot(block);
+                await expect(snapshotBuilder.snapshot(block)).resolves.toEqual(snapshot);
+            });
+            it('returns the same path if tree has not diverged', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const snapshot = await snapshotBuilder.snapshot(1);
+                const historicPaths = await Promise.all(leaves.map(leaf => snapshot.getSiblingPath(leaf)));
+                const expectedPaths = await Promise.all(leaves.map(leaf => tree.getSiblingPath(leaf, false)));
+                for (const [index, path] of historicPaths.entries()) {
+                    expect(path).toEqual(expectedPaths[index]);
+                }
+            });
+            it('returns historic paths if tree has diverged and no new snapshots have been taken', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const snapshot = await snapshotBuilder.snapshot(1);
+                const expectedPaths = await Promise.all(leaves.map(leaf => tree.getSiblingPath(leaf, false)));
+                await modifyTree(tree);
+                await tree.commit();
+                const historicPaths = await Promise.all(leaves.map(leaf => snapshot.getSiblingPath(leaf)));
+                for (const [index, path] of historicPaths.entries()) {
+                    expect(path).toEqual(expectedPaths[index]);
+                }
+            });
+            it('retains old snapshots even if new one are created', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const expectedPaths = await Promise.all(leaves.map(leaf => tree.getSiblingPath(leaf, false)));
+                const snapshot = await snapshotBuilder.snapshot(1);
+                await modifyTree(tree);
+                await tree.commit();
+                await snapshotBuilder.snapshot(2);
+                // check that snapshot 2 has not influenced snapshot(1) at all
+                const historicPaths = await Promise.all(leaves.map(leaf => snapshot.getSiblingPath(leaf)));
+                for (const [index, path] of historicPaths.entries()) {
+                    expect(path).toEqual(expectedPaths[index]);
+                }
+            });
+            it('retains old snapshots even if new one are created and the tree diverges', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const expectedPaths = await Promise.all(leaves.map(leaf => tree.getSiblingPath(leaf, false)));
+                const snapshot = await snapshotBuilder.snapshot(1);
+                await modifyTree(tree);
+                await tree.commit();
+                await snapshotBuilder.snapshot(2);
+                await modifyTree(tree);
+                await tree.commit();
+                // check that snapshot 2 has not influenced snapshot(1) at all
+                // and that the diverging tree does not influence the old snapshot
+                const historicPaths = await Promise.all(leaves.map(leaf => snapshot.getSiblingPath(leaf)));
+                for (const [index, path] of historicPaths.entries()) {
+                    expect(path).toEqual(expectedPaths[index]);
+                }
+            });
+        });
+        describe('getSnapshot', () => {
+            it('returns old snapshots', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const expectedPaths = await Promise.all(leaves.map(leaf => tree.getSiblingPath(leaf, false)));
+                await snapshotBuilder.snapshot(1);
+                for (let i = 2; i < 5; i++) {
+                    await modifyTree(tree);
+                    await tree.commit();
+                    await snapshotBuilder.snapshot(i);
+                }
+                const firstSnapshot = await snapshotBuilder.getSnapshot(1);
+                const historicPaths = await Promise.all(leaves.map(leaf => firstSnapshot.getSiblingPath(leaf)));
+                for (const [index, path] of historicPaths.entries()) {
+                    expect(path).toEqual(expectedPaths[index]);
+                }
+            });
+            it('throws if an unknown snapshot is requested', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                await snapshotBuilder.snapshot(1);
+                await expect(snapshotBuilder.getSnapshot(2)).rejects.toThrow();
+            });
+        });
+        describe('getRoot', () => {
+            it('returns the historical root of the tree when the snapshot was taken', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const snapshot = await snapshotBuilder.snapshot(1);
+                const historicalRoot = tree.getRoot(false);
+                await modifyTree(tree);
+                await tree.commit();
+                expect(snapshot.getRoot()).toEqual(historicalRoot);
+                expect(snapshot.getRoot()).not.toEqual(tree.getRoot(false));
+            });
+        });
+        describe('getDepth', () => {
+            it('returns the same depth as the tree', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const snapshot = await snapshotBuilder.snapshot(1);
+                expect(snapshot.getDepth()).toEqual(tree.getDepth());
+            });
+        });
+        describe('getNumLeaves', () => {
+            it('returns the historical leaves count when the snapshot was taken', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const snapshot = await snapshotBuilder.snapshot(1);
+                const historicalNumLeaves = tree.getNumLeaves(false);
+                await modifyTree(tree);
+                await tree.commit();
+                expect(snapshot.getNumLeaves()).toEqual(historicalNumLeaves);
+            });
+        });
+        describe('getLeafValue', () => {
+            it('returns the historical leaf value when the snapshot was taken', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const snapshot = await snapshotBuilder.snapshot(1);
+                const historicalLeafValue = await tree.getLeafValue(0n, false);
+                expect(await snapshot.getLeafValue(0n)).toEqual(historicalLeafValue);
+                await modifyTree(tree);
+                await tree.commit();
+                await expect(snapshot.getLeafValue(0n)).resolves.toEqual(historicalLeafValue);
+            });
+        });
+        describe('findLeafIndex', () => {
+            it('returns the historical leaf index when the snapshot was taken', async () => {
+                await modifyTree(tree);
+                await tree.commit();
+                const snapshot = await snapshotBuilder.snapshot(1);
+                const initialLastLeafIndex = tree.getNumLeaves(false) - 1n;
+                let lastLeaf = await tree.getLeafValue(initialLastLeafIndex, false);
+                expect(await snapshot.findLeafIndex(lastLeaf)).toBe(initialLastLeafIndex);
+                await modifyTree(tree);
+                await tree.commit();
+                const newLastLeafIndex = tree.getNumLeaves(false) - 1n;
+                lastLeaf = await tree.getLeafValue(newLastLeafIndex, false);
+                expect(await snapshot.findLeafIndex(lastLeaf)).toBe(undefined);
+            });
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot_builder_test_suite.js","sourceRoot":"","sources":["../../src/snapshots/snapshot_builder_test_suite.ts"],"names":[],"mappings":"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"}

package/dest/sparse_tree/sparse_tree.d.ts

@@ -1,15 +1,20 @@
 /// <reference types="node" resolution-mode="require"/>
 import { UpdateOnlyTree } from '../interfaces/update_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.
  */
 export declare class SparseTree extends TreeBase implements UpdateOnlyTree {
+    #private;
     /**
      * Updates a leaf in the tree.
      * @param leaf - New contents of the leaf.
      * @param index - Index of the leaf to be updated.
      */
     updateLeaf(leaf: Buffer, index: bigint): Promise<void>;
+    snapshot(block: number): Promise<TreeSnapshot>;
+    getSnapshot(block: number): Promise<TreeSnapshot>;
+    findLeafIndex(_value: Buffer, _includeUncommitted: boolean): Promise<bigint | undefined>;
 }
 //# sourceMappingURL=sparse_tree.d.ts.map