@aztec/merkle-tree 0.0.0-test.0

package/dest/snapshots/append_only_snapshot.js

@@ -0,0 +1,216 @@
+import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { SiblingPath } from '@aztec/foundation/trees';
+// stores the last block that modified this node
+const nodeModifiedAtBlockKey = (level, index)=>`node:${level}:${index}:modifiedAtBlock`;
+// stores the value of the node at the above block
+const historicalNodeKey = (level, index)=>`node:${level}:${index}:value`;
+/**
+ * A more space-efficient way of storing snapshots of AppendOnlyTrees that trades space need for slower
+ * sibling path reads.
+ *
+ * Complexity:
+ *
+ * N - count of non-zero nodes in tree
+ * M - count of snapshots
+ * H - tree height
+ *
+ * Space complexity: O(N + M) (N nodes - stores the last snapshot for each node and M - ints, for each snapshot stores up to which leaf its written to)
+ * Sibling path access:
+ *  Best case: O(H) database reads + O(1) hashes
+ *  Worst case: O(H) database reads + O(H) hashes
+ */ export class AppendOnlySnapshotBuilder {
+    db;
+    tree;
+    hasher;
+    deserializer;
+    #nodeValue;
+    #nodeLastModifiedByBlock;
+    #snapshotMetadata;
+    constructor(db, tree, hasher, deserializer){
+        this.db = db;
+        this.tree = tree;
+        this.hasher = hasher;
+        this.deserializer = deserializer;
+        const treeName = tree.getName();
+        this.#nodeValue = db.openMap(`append_only_snapshot:${treeName}:node`);
+        this.#nodeLastModifiedByBlock = db.openMap(`append_ony_snapshot:${treeName}:block`);
+        this.#snapshotMetadata = db.openMap(`append_only_snapshot:${treeName}:snapshot_metadata`);
+    }
+    getSnapshot(block) {
+        const meta = this.#getSnapshotMeta(block);
+        if (typeof meta === 'undefined') {
+            return Promise.reject(new Error(`Snapshot for tree ${this.tree.getName()} at block ${block} does not exist`));
+        }
+        return Promise.resolve(new AppendOnlySnapshot(this.#nodeValue, this.#nodeLastModifiedByBlock, block, meta.numLeaves, meta.root, this.tree, this.hasher, this.deserializer));
+    }
+    snapshot(block) {
+        return this.db.transaction(()=>{
+            const meta = this.#getSnapshotMeta(block);
+            if (typeof meta !== 'undefined') {
+                // no-op, we already have a snapshot
+                return new AppendOnlySnapshot(this.#nodeValue, this.#nodeLastModifiedByBlock, block, meta.numLeaves, meta.root, this.tree, this.hasher, this.deserializer);
+            }
+            const root = this.tree.getRoot(false);
+            const depth = this.tree.getDepth();
+            const queue = [
+                [
+                    root,
+                    0,
+                    0n
+                ]
+            ];
+            // walk the tree in BF and store latest nodes
+            while(queue.length > 0){
+                const [node, level, index] = queue.shift();
+                const historicalValue = this.#nodeValue.get(historicalNodeKey(level, index));
+                if (!historicalValue || !node.equals(historicalValue)) {
+                    // we've never seen this node before or it's different than before
+                    // update the historical tree and tag it with the block that modified it
+                    void this.#nodeLastModifiedByBlock.set(nodeModifiedAtBlockKey(level, index), block);
+                    void this.#nodeValue.set(historicalNodeKey(level, index), node);
+                } else {
+                    continue;
+                }
+                if (level + 1 > depth) {
+                    continue;
+                }
+                // these could be undefined because zero hashes aren't stored in the tree
+                const [lhs, rhs] = [
+                    this.tree.getNode(level + 1, 2n * index),
+                    this.tree.getNode(level + 1, 2n * index + 1n)
+                ];
+                if (lhs) {
+                    queue.push([
+                        lhs,
+                        level + 1,
+                        2n * index
+                    ]);
+                }
+                if (rhs) {
+                    queue.push([
+                        rhs,
+                        level + 1,
+                        2n * index + 1n
+                    ]);
+                }
+            }
+            const numLeaves = this.tree.getNumLeaves(false);
+            void this.#snapshotMetadata.set(block, {
+                numLeaves,
+                root
+            });
+            return new AppendOnlySnapshot(this.#nodeValue, this.#nodeLastModifiedByBlock, block, numLeaves, root, this.tree, this.hasher, this.deserializer);
+        });
+    }
+    #getSnapshotMeta(block) {
+        return this.#snapshotMetadata.get(block);
+    }
+}
+/**
+ * a
+ */ class AppendOnlySnapshot {
+    nodes;
+    nodeHistory;
+    block;
+    leafCount;
+    historicalRoot;
+    tree;
+    hasher;
+    deserializer;
+    constructor(nodes, nodeHistory, block, leafCount, historicalRoot, tree, hasher, deserializer){
+        this.nodes = nodes;
+        this.nodeHistory = nodeHistory;
+        this.block = block;
+        this.leafCount = leafCount;
+        this.historicalRoot = historicalRoot;
+        this.tree = tree;
+        this.hasher = hasher;
+        this.deserializer = deserializer;
+    }
+    getSiblingPath(index) {
+        const path = [];
+        const depth = this.tree.getDepth();
+        let level = depth;
+        while(level > 0){
+            const isRight = index & 0x01n;
+            const siblingIndex = isRight ? index - 1n : index + 1n;
+            const sibling = this.#getHistoricalNodeValue(level, siblingIndex);
+            path.push(sibling);
+            level -= 1;
+            index >>= 1n;
+        }
+        return new SiblingPath(depth, path);
+    }
+    getDepth() {
+        return this.tree.getDepth();
+    }
+    getNumLeaves() {
+        return this.leafCount;
+    }
+    getRoot() {
+        // we could recompute it, but it's way cheaper to just store the root
+        return this.historicalRoot;
+    }
+    getLeafValue(index) {
+        const leafLevel = this.getDepth();
+        const blockNumber = this.#getBlockNumberThatModifiedNode(leafLevel, index);
+        // leaf hasn't been set yet
+        if (typeof blockNumber === 'undefined') {
+            return undefined;
+        }
+        // leaf was set some time in the past
+        if (blockNumber <= this.block) {
+            const val = this.nodes.get(historicalNodeKey(leafLevel, index));
+            return val ? this.deserializer.fromBuffer(val) : undefined;
+        }
+        // leaf has been set but in a block in the future
+        return undefined;
+    }
+    #getHistoricalNodeValue(level, index) {
+        const blockNumber = this.#getBlockNumberThatModifiedNode(level, index);
+        // node has never been set
+        if (typeof blockNumber === 'undefined') {
+            return this.tree.getZeroHash(level);
+        }
+        // node was set some time in the past
+        if (blockNumber <= this.block) {
+            return this.nodes.get(historicalNodeKey(level, index));
+        }
+        // the node has been modified since this snapshot was taken
+        // because we're working with an AppendOnly tree, historical leaves never change
+        // so what we do instead is rebuild this Merkle path up using zero hashes as needed
+        // worst case this will do O(H) hashes
+        //
+        // we first check if this subtree was touched by the block
+        // compare how many leaves this block added to the leaf interval of this subtree
+        // if they don't intersect then the whole subtree was a hash of zero
+        // if they do then we need to rebuild the merkle tree
+        const depth = this.tree.getDepth();
+        const leafStart = index * 2n ** BigInt(depth - level);
+        if (leafStart >= this.leafCount) {
+            return this.tree.getZeroHash(level);
+        }
+        const [lhs, rhs] = [
+            this.#getHistoricalNodeValue(level + 1, 2n * index),
+            this.#getHistoricalNodeValue(level + 1, 2n * index + 1n)
+        ];
+        return this.hasher.hash(lhs, rhs);
+    }
+    #getBlockNumberThatModifiedNode(level, index) {
+        return this.nodeHistory.get(nodeModifiedAtBlockKey(level, index));
+    }
+    findLeafIndex(value) {
+        return this.findLeafIndexAfter(value, 0n);
+    }
+    findLeafIndexAfter(value, startIndex) {
+        const valueBuffer = serializeToBuffer(value);
+        const numLeaves = this.getNumLeaves();
+        for(let i = startIndex; i < numLeaves; i++){
+            const currentValue = this.getLeafValue(i);
+            if (currentValue && serializeToBuffer(currentValue).equals(valueBuffer)) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+}

package/dest/snapshots/base_full_snapshot.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type Bufferable, type FromBuffer } from '@aztec/foundation/serialize';
+import { SiblingPath } from '@aztec/foundation/trees';
+import type { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import type { TreeBase } from '../tree_base.js';
+import type { TreeSnapshot, TreeSnapshotBuilder } from './snapshot_builder.js';
+/**
+ * Metadata for a snapshot, per block
+ */
+type SnapshotMetadata = {
+    /** The tree root at the time */
+    root: Buffer;
+    /** The number of filled leaves */
+    numLeaves: bigint;
+};
+/**
+ * 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 declare abstract class BaseFullTreeSnapshotBuilder<T extends TreeBase<Bufferable>, S extends TreeSnapshot<Bufferable>> implements TreeSnapshotBuilder<S> {
+    #private;
+    protected db: AztecKVStore;
+    protected tree: T;
+    protected nodes: AztecMap<string, [Buffer, Buffer]>;
+    protected snapshotMetadata: AztecMap<number, SnapshotMetadata>;
+    constructor(db: AztecKVStore, tree: T);
+    snapshot(block: number): Promise<S>;
+    protected handleLeaf(_index: bigint, _node: Buffer): void;
+    getSnapshot(version: number): Promise<S>;
+    protected abstract openSnapshot(root: Buffer, numLeaves: bigint): S;
+}
+/**
+ * A source of sibling paths from a snapshot tree
+ */
+export declare class BaseFullTreeSnapshot<T extends Bufferable> implements TreeSnapshot<T> {
+    #private;
+    protected db: AztecMap<string, [Buffer, Buffer]>;
+    protected historicRoot: Buffer;
+    protected numLeaves: bigint;
+    protected tree: TreeBase<T>;
+    protected deserializer: FromBuffer<T>;
+    constructor(db: AztecMap<string, [Buffer, Buffer]>, historicRoot: Buffer, numLeaves: bigint, tree: TreeBase<T>, deserializer: FromBuffer<T>);
+    getSiblingPath<N extends number>(index: bigint): SiblingPath<N>;
+    getLeafValue(index: bigint): T | undefined;
+    getDepth(): number;
+    getRoot(): Buffer;
+    getNumLeaves(): bigint;
+    protected pathFromRootToLeaf(leafIndex: bigint): Generator<Buffer[], void, unknown>;
+    findLeafIndex(value: T): bigint | undefined;
+    findLeafIndexAfter(value: T, startIndex: bigint): bigint | undefined;
+}
+export {};
+//# sourceMappingURL=base_full_snapshot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base_full_snapshot.d.ts","sourceRoot":"","sources":["../../src/snapshots/base_full_snapshot.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAqB,MAAM,6BAA6B,CAAC;AAClG,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE/E;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,8BAAsB,2BAA2B,CAAC,CAAC,SAAS,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,SAAS,YAAY,CAAC,UAAU,CAAC,CAClH,YAAW,mBAAmB,CAAC,CAAC,CAAC;;IAKrB,SAAS,CAAC,EAAE,EAAE,YAAY;IAAE,SAAS,CAAC,IAAI,EAAE,CAAC;IAHzD,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,SAAS,CAAC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;gBAEzC,EAAE,EAAE,YAAY,EAAY,IAAI,EAAE,CAAC;IAKzD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAwDnC,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAEzD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAUxC,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,CAAC;CAKpE;AAED;;GAEG;AACH,qBAAa,oBAAoB,CAAC,CAAC,SAAS,UAAU,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;;IAE9E,SAAS,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,SAAS,CAAC,YAAY,EAAE,MAAM;IAC9B,SAAS,CAAC,SAAS,EAAE,MAAM;IAC3B,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC3B,SAAS,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC;gBAJ3B,EAAE,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC;IAGvC,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAc/D,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAS1C,QAAQ,IAAI,MAAM;IAIlB,OAAO,IAAI,MAAM;IAIjB,YAAY,IAAI,MAAM;IAItB,SAAS,CAAE,kBAAkB,CAAC,SAAS,EAAE,MAAM;IAwC/C,aAAa,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS;IAIpC,kBAAkB,CAAC,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAW5E"}

package/dest/snapshots/base_full_snapshot.js

@@ -0,0 +1,201 @@
+import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { SiblingPath } from '@aztec/foundation/trees';
+/**
+ * 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 {
+    db;
+    tree;
+    nodes;
+    snapshotMetadata;
+    constructor(db, tree){
+        this.db = db;
+        this.tree = tree;
+        this.nodes = db.openMap(`full_snapshot:${tree.getName()}:node`);
+        this.snapshotMetadata = db.openMap(`full_snapshot:${tree.getName()}:metadata`);
+    }
+    snapshot(block) {
+        return this.db.transaction(()=>{
+            const snapshotMetadata = this.#getSnapshotMeta(block);
+            if (snapshotMetadata) {
+                return this.openSnapshot(snapshotMetadata.root, snapshotMetadata.numLeaves);
+            }
+            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();
+                const nodeKey = node.toString('hex');
+                // 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
+                if (this.nodes.has(nodeKey)) {
+                    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
+                    this.handleLeaf(i, node);
+                    continue;
+                }
+                const [lhs, rhs] = [
+                    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);
+                void this.nodes.set(nodeKey, [
+                    lhs ?? zeroHash,
+                    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
+                    ]);
+                }
+            }
+            void this.snapshotMetadata.set(block, {
+                root,
+                numLeaves
+            });
+            return this.openSnapshot(root, numLeaves);
+        });
+    }
+    handleLeaf(_index, _node) {}
+    getSnapshot(version) {
+        const snapshotMetadata = this.#getSnapshotMeta(version);
+        if (!snapshotMetadata) {
+            return Promise.reject(new Error(`Version ${version} does not exist for tree ${this.tree.getName()}`));
+        }
+        return Promise.resolve(this.openSnapshot(snapshotMetadata.root, snapshotMetadata.numLeaves));
+    }
+    #getSnapshotMeta(block) {
+        return this.snapshotMetadata.get(block);
+    }
+}
+/**
+ * A source of sibling paths from a snapshot tree
+ */ export class BaseFullTreeSnapshot {
+    db;
+    historicRoot;
+    numLeaves;
+    tree;
+    deserializer;
+    constructor(db, historicRoot, numLeaves, tree, deserializer){
+        this.db = db;
+        this.historicRoot = historicRoot;
+        this.numLeaves = numLeaves;
+        this.tree = tree;
+        this.deserializer = deserializer;
+    }
+    getSiblingPath(index) {
+        const siblings = [];
+        for (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);
+    }
+    getLeafValue(index) {
+        let leafNode = undefined;
+        for (const [node, _sibling] of this.pathFromRootToLeaf(index)){
+            leafNode = node;
+        }
+        return leafNode ? this.deserializer.fromBuffer(leafNode) : undefined;
+    }
+    getDepth() {
+        return this.tree.getDepth();
+    }
+    getRoot() {
+        return this.historicRoot;
+    }
+    getNumLeaves() {
+        return this.numLeaves;
+    }
+    *pathFromRootToLeaf(leafIndex) {
+        const root = this.historicRoot;
+        const pathFromRoot = this.#getPathFromRoot(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 = this.db.get(node.toString('hex')) ?? [
+                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;
+        }
+    }
+    /**
+   * Calculates the path from the root to the target leaf. Returns an array of 0s and 1s,
+   * each 0 represents walking down a left child and each 1 walking down to the child on the right.
+   *
+   * @param leafIndex - The target leaf
+   * @returns An array of 0s and 1s
+   */ #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;
+    }
+    findLeafIndex(value) {
+        return this.findLeafIndexAfter(value, 0n);
+    }
+    findLeafIndexAfter(value, startIndex) {
+        const numLeaves = this.getNumLeaves();
+        const buffer = serializeToBuffer(value);
+        for(let i = startIndex; i < numLeaves; i++){
+            const currentValue = this.getLeafValue(i);
+            if (currentValue && serializeToBuffer(currentValue).equals(buffer)) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+}

package/dest/snapshots/full_snapshot.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Bufferable, FromBuffer } from '@aztec/foundation/serialize';
+import type { AztecKVStore } from '@aztec/kv-store';
+import type { TreeBase } from '../tree_base.js';
+import { BaseFullTreeSnapshotBuilder } from './base_full_snapshot.js';
+import type { 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<T extends Bufferable> extends BaseFullTreeSnapshotBuilder<TreeBase<T>, TreeSnapshot<T>> implements TreeSnapshotBuilder<TreeSnapshot<T>> {
+    private deserializer;
+    constructor(db: AztecKVStore, tree: TreeBase<T>, deserializer: FromBuffer<T>);
+    protected openSnapshot(root: Buffer, numLeaves: bigint): TreeSnapshot<T>;
+}
+//# 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,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAwB,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC5F,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE/E;;;;;;;;;;;;;GAaG;AACH,qBAAa,uBAAuB,CAAC,CAAC,SAAS,UAAU,CACvD,SAAQ,2BAA2B,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAChE,YAAW,mBAAmB,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAEE,OAAO,CAAC,YAAY;gBAAzD,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAU,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC;IAIpF,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC;CAGzE"}

package/dest/snapshots/full_snapshot.js

@@ -0,0 +1,23 @@
+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 {
+    deserializer;
+    constructor(db, tree, deserializer){
+        super(db, tree), this.deserializer = deserializer;
+    }
+    openSnapshot(root, numLeaves) {
+        return new BaseFullTreeSnapshot(this.nodes, root, numLeaves, this.tree, this.deserializer);
+    }
+}

package/dest/snapshots/indexed_tree_snapshot.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import type { IndexedTree, PreimageFactory } from '../interfaces/indexed_tree.js';
+import type { TreeBase } from '../tree_base.js';
+import { BaseFullTreeSnapshotBuilder } from './base_full_snapshot.js';
+import type { IndexedTreeSnapshot, TreeSnapshotBuilder } from './snapshot_builder.js';
+/** a */
+export declare class IndexedTreeSnapshotBuilder extends BaseFullTreeSnapshotBuilder<IndexedTree & TreeBase<Buffer>, IndexedTreeSnapshot> implements TreeSnapshotBuilder<IndexedTreeSnapshot> {
+    private leafPreimageBuilder;
+    leaves: AztecMap<string, Buffer>;
+    constructor(store: AztecKVStore, tree: IndexedTree & TreeBase<Buffer>, leafPreimageBuilder: PreimageFactory);
+    protected openSnapshot(root: Buffer, numLeaves: bigint): IndexedTreeSnapshot;
+    protected handleLeaf(index: bigint, node: Buffer): 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":";;AACA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAClF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAwB,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC5F,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAItF,QAAQ;AACR,qBAAa,0BACX,SAAQ,2BAA2B,CAAC,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CACvF,YAAW,mBAAmB,CAAC,mBAAmB,CAAC;IAGoB,OAAO,CAAC,mBAAmB;IADlG,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBACrB,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,EAAU,mBAAmB,EAAE,eAAe;IAKnH,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,mBAAmB;cAIzD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAM1D"}

package/dest/snapshots/indexed_tree_snapshot.js

@@ -0,0 +1,79 @@
+import { BaseFullTreeSnapshot, BaseFullTreeSnapshotBuilder } from './base_full_snapshot.js';
+const snapshotLeafValue = (node, index)=>'snapshot:leaf:' + node.toString('hex') + ':' + index;
+/** a */ export class IndexedTreeSnapshotBuilder extends BaseFullTreeSnapshotBuilder {
+    leafPreimageBuilder;
+    leaves;
+    constructor(store, tree, leafPreimageBuilder){
+        super(store, tree), this.leafPreimageBuilder = leafPreimageBuilder;
+        this.leaves = store.openMap('indexed_tree_snapshot:' + tree.getName());
+    }
+    openSnapshot(root, numLeaves) {
+        return new IndexedTreeSnapshotImpl(this.nodes, this.leaves, root, numLeaves, this.tree, this.leafPreimageBuilder);
+    }
+    handleLeaf(index, node) {
+        const leafPreimage = this.tree.getLatestLeafPreimageCopy(index, false);
+        if (leafPreimage) {
+            void this.leaves.set(snapshotLeafValue(node, index), leafPreimage.toBuffer());
+        }
+    }
+}
+/** A snapshot of an indexed tree at a particular point in time */ class IndexedTreeSnapshotImpl extends BaseFullTreeSnapshot {
+    leaves;
+    leafPreimageBuilder;
+    constructor(db, leaves, historicRoot, numLeaves, tree, leafPreimageBuilder){
+        super(db, historicRoot, numLeaves, tree, {
+            fromBuffer: (buf)=>buf
+        }), this.leaves = leaves, this.leafPreimageBuilder = leafPreimageBuilder;
+    }
+    getLeafValue(index) {
+        const leafPreimage = this.getLatestLeafPreimageCopy(index);
+        return leafPreimage?.toBuffer();
+    }
+    getLatestLeafPreimageCopy(index) {
+        const leafNode = super.getLeafValue(index);
+        const leafValue = this.leaves.get(snapshotLeafValue(leafNode, index));
+        if (leafValue) {
+            return this.leafPreimageBuilder.fromBuffer(leafValue);
+        } else {
+            return undefined;
+        }
+    }
+    findIndexOfPreviousKey(newValue) {
+        const numLeaves = this.getNumLeaves();
+        const diff = [];
+        for(let i = 0; i < numLeaves; i++){
+            // this is very inefficient
+            const storedLeaf = 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
+        };
+    }
+    findLeafIndex(value) {
+        const index = this.tree.findLeafIndex(value, false);
+        if (index !== undefined && index < this.getNumLeaves()) {
+            return index;
+        }
+    }
+}