@aztec/merkle-tree 0.16.1 → 0.16.3

package/dest/sparse_tree/sparse_tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sparse_tree.d.ts","sourceRoot":"","sources":["../../src/sparse_tree/sparse_tree.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAgB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;GAEG;AACH,qBAAa,UAAW,SAAQ,QAAS,YAAW,cAAc;IAChE;;;;OAIG;IACU,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAmBpE"}
+{"version":3,"file":"sparse_tree.d.ts","sourceRoot":"","sources":["../../src/sparse_tree/sparse_tree.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAgB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;GAEG;AACH,qBAAa,UAAW,SAAQ,QAAS,YAAW,cAAc;;IAGhE;;;;OAIG;IACU,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB5D,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAI9C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAIjD,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;CAGhG"}

package/dest/sparse_tree/sparse_tree.js

@@ -1,8 +1,15 @@
+var _SparseTree_snapshotBuilder;
+import { __classPrivateFieldGet } from "tslib";
+import { FullTreeSnapshotBuilder } from '../snapshots/full_snapshot.js';
 import { INITIAL_LEAF, TreeBase } from '../tree_base.js';
 /**
  * A Merkle tree implementation that uses a LevelDB database to store the tree.
  */
 export class SparseTree extends TreeBase {
+    constructor() {
+        super(...arguments);
+        _SparseTree_snapshotBuilder.set(this, new FullTreeSnapshotBuilder(this.db, this));
+    }
     /**
      * Updates a leaf in the tree.
      * @param leaf - New contents of the leaf.
@@ -27,5 +34,15 @@ export class SparseTree extends TreeBase {
             this.cachedSize = (this.cachedSize ?? this.size) + 1n;
         }
     }
+    snapshot(block) {
+        return __classPrivateFieldGet(this, _SparseTree_snapshotBuilder, "f").snapshot(block);
+    }
+    getSnapshot(block) {
+        return __classPrivateFieldGet(this, _SparseTree_snapshotBuilder, "f").getSnapshot(block);
+    }
+    findLeafIndex(_value, _includeUncommitted) {
+        throw new Error('Finding leaf index is not supported for sparse trees');
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhcnNlX3RyZWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3BhcnNlX3RyZWUvc3BhcnNlX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUV6RDs7R0FFRztBQUNILE1BQU0sT0FBTyxVQUFXLFNBQVEsUUFBUTtJQUN0Qzs7OztPQUlHO0lBQ0ksS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFZLEVBQUUsS0FBYTtRQUNqRCxJQUFJLEtBQUssR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ3pCLE1BQU0sS0FBSyxDQUFDLDhCQUE4QixLQUFLLGdCQUFnQixJQUFJLENBQUMsUUFBUSxHQUFHLENBQUMsQ0FBQztTQUNsRjtRQUVELE1BQU0sb0JBQW9CLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN2RCxNQUFNLHFCQUFxQixHQUFHLENBQUMsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUMzRixJQUFJLG9CQUFvQixJQUFJLHFCQUFxQixFQUFFO1lBQ2pELE9BQU87U0FDUjtRQUNELE1BQU0sSUFBSSxDQUFDLDJCQUEyQixDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztRQUNwRCxJQUFJLG9CQUFvQixFQUFFO1lBQ3hCLCtEQUErRDtZQUMvRCxJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1NBQ3ZEO2FBQU0sSUFBSSxxQkFBcUIsRUFBRTtZQUNoQyxvRUFBb0U7WUFDcEUsSUFBSSxDQUFDLFVBQVUsR0FBRyxDQUFDLElBQUksQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztTQUN2RDtJQUNILENBQUM7Q0FDRiJ9
+_SparseTree_snapshotBuilder = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhcnNlX3RyZWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3BhcnNlX3RyZWUvc3BhcnNlX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFDQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUV4RSxPQUFPLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRXpEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFVBQVcsU0FBUSxRQUFRO0lBQXhDOztRQUNFLHNDQUFtQixJQUFJLHVCQUF1QixDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsSUFBSSxDQUFDLEVBQUM7SUFzQ2hFLENBQUM7SUFwQ0M7Ozs7T0FJRztJQUNJLEtBQUssQ0FBQyxVQUFVLENBQUMsSUFBWSxFQUFFLEtBQWE7UUFDakQsSUFBSSxLQUFLLEdBQUcsSUFBSSxDQUFDLFFBQVEsRUFBRTtZQUN6QixNQUFNLEtBQUssQ0FBQyw4QkFBOEIsS0FBSyxnQkFBZ0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxDQUFDLENBQUM7U0FDbEY7UUFFRCxNQUFNLG9CQUFvQixHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDdkQsTUFBTSxxQkFBcUIsR0FBRyxDQUFDLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUMsRUFBRSxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDM0YsSUFBSSxvQkFBb0IsSUFBSSxxQkFBcUIsRUFBRTtZQUNqRCxPQUFPO1NBQ1I7UUFDRCxNQUFNLElBQUksQ0FBQywyQkFBMkIsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDcEQsSUFBSSxvQkFBb0IsRUFBRTtZQUN4QiwrREFBK0Q7WUFDL0QsSUFBSSxDQUFDLFVBQVUsR0FBRyxDQUFDLElBQUksQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztTQUN2RDthQUFNLElBQUkscUJBQXFCLEVBQUU7WUFDaEMsb0VBQW9FO1lBQ3BFLElBQUksQ0FBQyxVQUFVLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7U0FDdkQ7SUFDSCxDQUFDO0lBRU0sUUFBUSxDQUFDLEtBQWE7UUFDM0IsT0FBTyx1QkFBQSxJQUFJLG1DQUFpQixDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRU0sV0FBVyxDQUFDLEtBQWE7UUFDOUIsT0FBTyx1QkFBQSxJQUFJLG1DQUFpQixDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNsRCxDQUFDO0lBRU0sYUFBYSxDQUFDLE1BQWMsRUFBRSxtQkFBNEI7UUFDL0QsTUFBTSxJQUFJLEtBQUssQ0FBQyxzREFBc0QsQ0FBQyxDQUFDO0lBQzFFLENBQUM7Q0FDRiJ9

package/dest/standard_indexed_tree/standard_indexed_tree.d.ts

@@ -1,32 +1,63 @@
 /// <reference types="node" resolution-mode="require"/>
-import { SiblingPath } from '@aztec/types';
-import { IndexedTree, LeafData } from '../interfaces/indexed_tree.js';
+import { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+import { Hasher, SiblingPath } from '@aztec/types';
+import { LevelUp } from 'levelup';
+import { BatchInsertionResult, IndexedTree, IndexedTreeSnapshot } from '../index.js';
 import { TreeBase } from '../tree_base.js';
 /**
- * All of the data to be return during batch insertion.
+ * Factory for creating leaf preimages.
  */
-export interface LowLeafWitnessData<N extends number> {
+export interface PreimageFactory {
     /**
-     * Preimage of the low nullifier that proves non membership.
+     * 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.
      */
-    leafData: LeafData;
+    fromLeaf(leaf: IndexedTreeLeaf, nextKey: bigint, nextIndex: bigint): IndexedTreeLeafPreimage;
     /**
-     * Sibling path to prove membership of low nullifier.
+     * Creates a new preimage from a buffer.
+     * @param buffer - Buffer to create a preimage from.
      */
-    siblingPath: SiblingPath<N>;
+    fromBuffer(buffer: Buffer): IndexedTreeLeafPreimage;
     /**
-     * The index of low nullifier.
+     * Creates an empty preimage.
      */
-    index: bigint;
+    empty(): IndexedTreeLeafPreimage;
+    /**
+     * Creates a copy of a preimage.
+     * @param preimage - Preimage to be cloned.
+     */
+    clone(preimage: IndexedTreeLeafPreimage): IndexedTreeLeafPreimage;
+}
+/**
+ * Factory for creating leaves.
+ */
+export interface LeafFactory {
+    /**
+     * Creates a new leaf from a buffer.
+     * @param key - Key of the leaf.
+     */
+    buildDummy(key: bigint): IndexedTreeLeaf;
+    /**
+     * Creates a new leaf from a buffer.
+     * @param buffer - Buffer to create a leaf from.
+     */
+    fromBuffer(buffer: Buffer): IndexedTreeLeaf;
 }
+export declare const buildDbKeyForPreimage: (name: string, index: bigint) => string;
+export declare const buildDbKeyForLeafIndex: (name: string, key: bigint) => string;
 /**
- * Indexed merkle tree.
+ * Standard implementation of an indexed tree.
  */
 export declare class StandardIndexedTree extends TreeBase implements IndexedTree {
-    protected leaves: LeafData[];
-    protected cachedLeaves: {
-        [key: number]: LeafData;
+    #private;
+    protected leafPreimageFactory: PreimageFactory;
+    protected leafFactory: LeafFactory;
+    protected cachedLeafPreimages: {
+        [key: string]: IndexedTreeLeafPreimage;
     };
+    constructor(db: LevelUp, 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.
@@ -53,33 +84,39 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
     getLeafValue(index: bigint, includeUncommitted: boolean): Promise<Buffer | 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.
+     * @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`.
      */
-    findIndexOfPreviousValue(newValue: bigint, includeUncommitted: boolean): {
+    findIndexOfPreviousKey(newKey: bigint, includeUncommitted: boolean): Promise<{
         /**
          * The index of the found leaf.
          */
-        index: number;
+        index: bigint;
         /**
          * A flag indicating if the corresponding leaf's value is equal to `newValue`.
          */
         alreadyPresent: boolean;
-    };
+    } | undefined>;
+    private getCachedLowLeafIndex;
+    private getCachedLeafIndex;
+    private getDbLowLeafIndex;
+    private getDbPreimage;
+    private getCachedPreimage;
     /**
-     * Gets the latest LeafData copy.
-     * @param index - Index of the leaf of which to obtain the LeafData copy.
+     * Gets the latest LeafPreimage copy.
+     * @param index - Index of the leaf of which to obtain the LeafPreimage copy.
      * @param includeUncommitted - If true, the uncommitted changes are included in the search.
-     * @returns A copy of the leaf data at the given index or undefined if the leaf was not found.
+     * @returns A copy of the leaf preimage at the given index or undefined if the leaf was not found.
      */
-    getLatestLeafDataCopy(index: number, includeUncommitted: boolean): LeafData | undefined;
+    getLatestLeafPreimageCopy(index: bigint, includeUncommitted: boolean): Promise<IndexedTreeLeafPreimage | undefined>;
     /**
-     * Finds the index of the minimum value in an array.
-     * @param values - The collection of values to be searched.
-     * @returns The index of the minimum value in the array.
+     * 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).
      */
-    private findMinIndex;
+    findLeafIndex(value: Buffer, includeUncommitted: boolean): Promise<bigint | undefined>;
     /**
      * Initializes the tree.
      * @param prefilledSize - A number of leaves that are prefilled with values.
@@ -95,10 +132,6 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
      *    more leaves, we can then insert the first block of 1024 leaves into indices 1024:2047.
      */
     init(prefilledSize: number): Promise<void>;
-    /**
-     * Loads Merkle tree data from a database and assigns them to this object.
-     */
-    initFromDb(): Promise<void>;
     /**
      * Commits all the leaves to the database and removes them from a cache.
      */
@@ -109,10 +142,10 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
     private clearCachedLeaves;
     /**
      * Updates a leaf in the tree.
-     * @param leaf - New contents of the leaf.
+     * @param preimage - New contents of the leaf.
      * @param index - Index of the leaf to be updated.
      */
-    protected updateLeaf(leaf: LeafData, index: bigint): Promise<void>;
+    protected updateLeaf(preimage: IndexedTreeLeafPreimage, index: bigint): Promise<void>;
     /**
      *
      * Each base rollup needs to provide non membership / inclusion proofs for each of the nullifier.
@@ -121,8 +154,6 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
      *
      * This offers massive circuit performance savings over doing incremental insertions.
      *
-     * A description of the algorithm can be found here: https://colab.research.google.com/drive/1A0gizduSi4FIiIJZ8OylwIpO9-OTqV-R
-     *
      * WARNING: This function has side effects, it will insert values into the tree.
      *
      * Assumptions:
@@ -142,92 +173,91 @@ export declare class StandardIndexedTree extends TreeBase implements IndexedTree
      * roots.
      *
      * This become tricky when two items that are being batch inserted need to update the same low nullifier, or need to use
-     * a value that is part of the same batch insertion as their low nullifier. In this case a zero low nullifier path is given
-     * to the circuit, and it must determine from the set of batch inserted values if the insertion is valid.
+     * a value that is part of the same batch insertion as their low nullifier. What we do to avoid this case is to
+     * update the existing leaves in the tree with the nullifiers in high to low order, ensuring that this case never occurs.
+     * The circuit has to sort the nullifiers (or take a hint of the sorted nullifiers and prove that it's a valid permutation).
+     * Then we just batch insert the new nullifiers in the original order.
      *
      * The following example will illustrate attempting to insert 2,3,20,19 into a tree already containing 0,5,10,15
      *
      * The example will explore two cases. In each case the values low nullifier will exist within the batch insertion,
      * One where the low nullifier comes before the item in the set (2,3), and one where it comes after (20,19).
      *
+     * First, we sort the nullifiers high to low, that's 20,19,3,2
+     *
      * The original tree:                       Pending insertion subtree
      *
-     *  index     0       2       3       4         -       -       -       -
+     *  index     0       1       2       3         -       -       -       -
      *  -------------------------------------      ----------------------------
      *  val       0       5      10      15         -       -       -       -
      *  nextIdx   1       2       3       0         -       -       -       -
      *  nextVal   5      10      15       0         -       -       -       -
      *
      *
-     * Inserting 2: (happy path)
-     * 1. Find the low nullifier (0) - provide inclusion proof
+     * Inserting 20:
+     * 1. Find the low nullifier (3) - provide inclusion proof
      * 2. Update its pointers
-     * 3. Insert 2 into the pending subtree
+     * 3. Insert 20 into the pending subtree
      *
-     *  index     0       2       3       4         5       -       -       -
+     *  index     0       1       2       3         -       -       6       -
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       -       -       -
-     *  nextIdx   5       2       3       0         2       -       -       -
-     *  nextVal   2      10      15       0         5       -       -       -
-     *
-     * Inserting 3: The low nullifier exists within the insertion current subtree
-     * 1. When looking for the low nullifier for 3, we will receive 0 again as we have not inserted 2 into the main tree
-     *    This is problematic, as we cannot use either 0 or 2 as our inclusion proof.
-     *    Why cant we?
-     *      - Index 0 has a val 0 and nextVal of 2. This is NOT enough to prove non inclusion of 2.
-     *      - Our existing tree is in a state where we cannot prove non inclusion of 3.
-     *    We do not provide a non inclusion proof to out circuit, but prompt it to look within the insertion subtree.
-     * 2. Update pending insertion subtree
-     * 3. Insert 3 into pending subtree
-     *
-     * (no inclusion proof provided)
-     *  index     0       2       3       4         5       6       -       -
+     *  val       0       5      10      15         -       -      20       -
+     *  nextIdx   1       2       3       6         -       -       0       -
+     *  nextVal   5      10      15      20         -       -       0       -
+     *
+     * Inserting 19:
+     * 1. Find the low nullifier (3) - provide inclusion proof
+     * 2. Update its pointers
+     * 3. Insert 19 into the pending subtree
+     *
+     *  index     0       1       2       3         -       -       6       7
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       3       -       -
-     *  nextIdx   5       2       3       0         6       2       -       -
-     *  nextVal   2      10      15       0         3       5       -       -
+     *  val       0       5      10      15         -       -      20      19
+     *  nextIdx   1       2       3       7         -       -       0       6
+     *  nextVal   5      10      15      19         -       -       0      20
      *
-     * Inserting 20: (happy path)
-     * 1. Find the low nullifier (15) - provide inclusion proof
+     * Inserting 3:
+     * 1. Find the low nullifier (0) - provide inclusion proof
      * 2. Update its pointers
-     * 3. Insert 20 into the pending subtree
+     * 3. Insert 3 into the pending subtree
      *
-     *  index     0       2       3       4         5       6       7       -
+     *  index     0       1       2       3         -       5       6       7
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       3      20       -
-     *  nextIdx   5       2       3       7         6       2       0       -
-     *  nextVal   2      10      15      20         3       5       0       -
+     *  val       0       5      10      15         -       3      20      19
+     *  nextIdx   5       2       3       7         -       1       0       6
+     *  nextVal   3      10      15      19         -       5       0      20
      *
-     * Inserting 19:
-     * 1. In this case we can find a low nullifier, but we are updating a low nullifier that has already been updated
-     *    We can provide an inclusion proof of this intermediate tree state.
+     * Inserting 2:
+     * 1. Find the low nullifier (0) - provide inclusion proof
      * 2. Update its pointers
-     * 3. Insert 19 into the pending subtree
+     * 3. Insert 2 into the pending subtree
      *
-     *  index     0       2       3       4         5       6       7       8
+     *  index     0       1       2       3         4       5       6       7
      *  -------------------------------------      ----------------------------
-     *  val       0       5      10      15         2       3      20       19
-     *  nextIdx   5       2       3       8         6       2       0       7
-     *  nextVal   2      10      15      19         3       5       0       20
+     *  val       0       5      10      15         2       3      20      19
+     *  nextIdx   4       2       3       7         5       1       0       6
+     *  nextVal   2      10      15      19         3       5       0      20
      *
      * Perform subtree insertion
      *
-     *  index     0       2       3       4       5       6       7       8
+     *  index     0       1       2       3       4       5       6       7
      *  ---------------------------------------------------------------------
-     *  val       0       5      10      15       2       3      20       19
-     *  nextIdx   5       2       3       8       6       2       0       7
-     *  nextVal   2      10      15      19       3       5       0       20
+     *  val       0       5      10      15       2       3      20      19
+     *  nextIdx   4       2       3       7       5       1       0       6
+     *  nextVal   2      10      15      19       3       5       0      20
      *
      * TODO: this implementation will change once the zero value is changed from h(0,0,0). Changes incoming over the next sprint
      * @param leaves - Values to insert into the tree.
      * @param subtreeHeight - Height of the subtree.
      * @returns The data for the leaves to be updated when inserting the new ones.
      */
-    batchInsert<TreeHeight extends number, SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(leaves: Buffer[], subtreeHeight: SubtreeHeight): Promise<[LowLeafWitnessData<TreeHeight>[], SiblingPath<SubtreeSiblingPathHeight>] | [undefined, SiblingPath<SubtreeSiblingPathHeight>]>;
+    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>;
     /**
      * Encodes leaves and appends them to a tree.
-     * @param leaves - Leaves to encode.
+     * @param preimages - Leaves to encode.
      * @param hash0Leaf - Indicates whether 0 value leaf should be hashed. See {@link encodeLeaf}.
      * @returns Empty promise
      */

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":";AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAmB3C;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,MAAM;IAClD;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;IACnB;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC5B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAkCD;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,QAAS,YAAW,WAAW;IACtE,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAM;IAClC,SAAS,CAAC,YAAY,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;KAAE,CAAM;IAEzD;;;;;OAKG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD;;;OAGG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKpC;;;OAGG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC;;;;;OAKG;IACI,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAQ5F;;;;;OAKG;IACH,wBAAwB,CACtB,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,OAAO,GAC1B;QACD;;WAEG;QACH,KAAK,EAAE,MAAM,CAAC;QACd;;WAEG;QACH,cAAc,EAAE,OAAO,CAAC;KACzB;IAuBD;;;;;OAKG;IACI,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS;IAW9F;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAapB;;;;;;;;;;;;;OAaG;IACU,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BvD;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BxC;;OAEG;YACW,YAAY;IAY1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;;;OAIG;cACa,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM;IAgBxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6GG;IACU,WAAW,CACtB,UAAU,SAAS,MAAM,EACzB,aAAa,SAAS,MAAM,EAC5B,wBAAwB,SAAS,MAAM,EAEvC,MAAM,EAAE,MAAM,EAAE,EAChB,aAAa,EAAE,aAAa,GAC3B,OAAO,CACN,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,EAAE,WAAW,CAAC,wBAAwB,CAAC,CAAC,GACzE,CAAC,SAAS,EAAE,WAAW,CAAC,wBAAwB,CAAC,CAAC,CACrD;IAgHK,qBAAqB,CAAC,aAAa,SAAS,MAAM,EAAE,wBAAwB,SAAS,MAAM,EAC/F,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,OAAO,GAC1B,OAAO,CAAC,WAAW,CAAC,wBAAwB,CAAC,CAAC;IAQjD;;;;;OAKG;YACW,qBAAqB;IAWnC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;CAWnB"}
+{"version":3,"file":"standard_indexed_tree.d.ts","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":"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"}