@aztec/merkle-tree 0.1.0-alpha10

package/dest/standard_indexed_tree/standard_indexed_tree.test.js

@@ -0,0 +1,316 @@
+import { default as levelup } from 'levelup';
+import { INITIAL_LEAF, Pedersen, SiblingPath } from '../index.js';
+import { StandardIndexedTree } from './standard_indexed_tree.js';
+import { treeTestSuite } from '../test/test_suite.js';
+import { createMemDown } from '../test/utils/create_mem_down.js';
+import { newTree } from '../new_tree.js';
+import { loadTree } from '../load_tree.js';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { CircuitsWasm } from '@aztec/circuits.js';
+const createDb = async (levelUp, hasher, name, depth) => {
+    return await newTree(StandardIndexedTree, levelUp, hasher, name, depth);
+};
+const createFromName = async (levelUp, hasher, name) => {
+    return await loadTree(StandardIndexedTree, levelUp, hasher, name);
+};
+const createIndexedTreeLeaf = (value, nextIndex, nextValue) => {
+    return [toBufferBE(BigInt(value), 32), toBufferBE(BigInt(nextIndex), 32), toBufferBE(BigInt(nextValue), 32)];
+};
+const verifyCommittedState = async (tree, root, siblingPathIndex, emptySiblingPath) => {
+    expect(tree.getRoot(false)).toEqual(root);
+    expect(tree.getNumLeaves(false)).toEqual(1n);
+    expect(await tree.getSiblingPath(siblingPathIndex, false)).toEqual(emptySiblingPath);
+};
+const TEST_TREE_DEPTH = 3;
+treeTestSuite('StandardIndexedTree', createDb, createFromName);
+describe('StandardIndexedTreeSpecific', () => {
+    let wasm;
+    let pedersen;
+    beforeEach(async () => {
+        wasm = await CircuitsWasm.get();
+        pedersen = new Pedersen(wasm);
+    });
+    it('produces the correct roots and sibling paths', async () => {
+        // Create a depth-3 indexed merkle tree
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', 3);
+        /**
+         * Initial state:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       0       0       0        0       0       0       0
+         *  nextIdx   0       0       0       0        0       0       0       0
+         *  nextVal   0       0       0       0        0       0       0       0.
+         */
+        const initialLeafHash = pedersen.compressInputs(createIndexedTreeLeaf(0, 0, 0));
+        const level1ZeroHash = pedersen.compress(INITIAL_LEAF, INITIAL_LEAF);
+        const level2ZeroHash = pedersen.compress(level1ZeroHash, level1ZeroHash);
+        let index0Hash = initialLeafHash;
+        // Each element is named by the level followed by the index on that level. E.g. e10 -> level 1, index 0, e21 -> level 2, index 1
+        let e10 = pedersen.compress(index0Hash, INITIAL_LEAF);
+        let e20 = pedersen.compress(e10, level1ZeroHash);
+        const initialE20 = e20; // Kept for calculating committed state later
+        const initialE10 = e10;
+        let root = pedersen.compress(e20, level2ZeroHash);
+        const initialRoot = root;
+        const emptySiblingPath = new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, level2ZeroHash]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+        expect(await tree.getSiblingPath(0n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, level2ZeroHash]));
+        await verifyCommittedState(tree, initialRoot, 0n, emptySiblingPath);
+        /**
+         * Add new value 30:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       30      0       0        0       0       0       0
+         *  nextIdx   1       0       0       0        0       0       0       0
+         *  nextVal   30      0       0       0        0       0       0       0.
+         */
+        index0Hash = pedersen.compressInputs(createIndexedTreeLeaf(0, 1, 30));
+        let index1Hash = pedersen.compressInputs(createIndexedTreeLeaf(30, 0, 0));
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        e20 = pedersen.compress(e10, level1ZeroHash);
+        root = pedersen.compress(e20, level2ZeroHash);
+        await tree.appendLeaves([toBufferBE(30n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(2n);
+        expect(await tree.getSiblingPath(1n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index0Hash, level1ZeroHash, level2ZeroHash]));
+        // ensure the committed state is correct
+        const initialSiblingPath = new SiblingPath(TEST_TREE_DEPTH, [initialLeafHash, level1ZeroHash, level2ZeroHash]);
+        await verifyCommittedState(tree, initialRoot, 1n, initialSiblingPath);
+        /**
+         * Add new value 10:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       30      10      0        0       0       0       0
+         *  nextIdx   2       0       1       0        0       0       0       0
+         *  nextVal   10      0       30      0        0       0       0       0.
+         */
+        index0Hash = pedersen.compressInputs(createIndexedTreeLeaf(0, 2, 10));
+        let index2Hash = pedersen.compressInputs(createIndexedTreeLeaf(10, 1, 30));
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        let e11 = pedersen.compress(index2Hash, INITIAL_LEAF);
+        e20 = pedersen.compress(e10, e11);
+        root = pedersen.compress(e20, level2ZeroHash);
+        await tree.appendLeaves([toBufferBE(10n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(3n);
+        expect(await tree.getSiblingPath(2n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, e10, level2ZeroHash]));
+        // ensure the committed state is correct
+        await verifyCommittedState(tree, initialRoot, 2n, new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, initialE10, level2ZeroHash]));
+        /**
+         * Add new value 20:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       30      10      20       0       0       0       0
+         *  nextIdx   2       0       3       1        0       0       0       0
+         *  nextVal   10      0       20      30       0       0       0       0.
+         */
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        index2Hash = pedersen.compressInputs(createIndexedTreeLeaf(10, 3, 20));
+        const index3Hash = pedersen.compressInputs(createIndexedTreeLeaf(20, 1, 30));
+        e11 = pedersen.compress(index2Hash, index3Hash);
+        e20 = pedersen.compress(e10, e11);
+        root = pedersen.compress(e20, level2ZeroHash);
+        await tree.appendLeaves([toBufferBE(20n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(4n);
+        expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index2Hash, e10, level2ZeroHash]));
+        // ensure the committed state is correct
+        await verifyCommittedState(tree, initialRoot, 3n, new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, initialE10, level2ZeroHash]));
+        /**
+         * Add new value 50:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       30      10      20       50      0       0       0
+         *  nextIdx   2       4       3       1        0       0       0       0
+         *  nextVal   10      50      20      30       0       0       0       0.
+         */
+        index1Hash = pedersen.compressInputs(createIndexedTreeLeaf(30, 4, 50));
+        const index4Hash = pedersen.compressInputs(createIndexedTreeLeaf(50, 0, 0));
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        e20 = pedersen.compress(e10, e11);
+        const e12 = pedersen.compress(index4Hash, INITIAL_LEAF);
+        const e21 = pedersen.compress(e12, level1ZeroHash);
+        root = pedersen.compress(e20, e21);
+        await tree.appendLeaves([toBufferBE(50n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(5n);
+        // ensure the committed state is correct
+        await verifyCommittedState(tree, initialRoot, 4n, new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, initialE20]));
+        // check all uncommitted hash paths
+        expect(await tree.getSiblingPath(0n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index1Hash, e11, e21]));
+        expect(await tree.getSiblingPath(1n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index0Hash, e11, e21]));
+        expect(await tree.getSiblingPath(2n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index3Hash, e10, e21]));
+        expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index2Hash, e10, e21]));
+        expect(await tree.getSiblingPath(4n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, e20]));
+        expect(await tree.getSiblingPath(5n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index4Hash, level1ZeroHash, e20]));
+        expect(await tree.getSiblingPath(6n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, e12, e20]));
+        expect(await tree.getSiblingPath(7n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, e12, e20]));
+        // check all committed hash paths
+        expect(await tree.getSiblingPath(0n, false)).toEqual(emptySiblingPath);
+        expect(await tree.getSiblingPath(1n, false)).toEqual(initialSiblingPath);
+        expect(await tree.getSiblingPath(2n, false)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, initialE10, level2ZeroHash]));
+        expect(await tree.getSiblingPath(3n, false)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, initialE10, level2ZeroHash]));
+        const e2SiblingPath = new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, initialE20]);
+        expect(await tree.getSiblingPath(4n, false)).toEqual(e2SiblingPath);
+        expect(await tree.getSiblingPath(5n, false)).toEqual(e2SiblingPath);
+        expect(await tree.getSiblingPath(6n, false)).toEqual(e2SiblingPath);
+        expect(await tree.getSiblingPath(7n, false)).toEqual(e2SiblingPath);
+        await tree.commit();
+        // check all committed hash paths equal uncommitted hash paths
+        for (let i = 0; i < 8; i++) {
+            expect(await tree.getSiblingPath(BigInt(i), false)).toEqual(await tree.getSiblingPath(BigInt(i), true));
+        }
+    });
+    it('Can append empty leaves and handle insertions', async () => {
+        // Create a depth-3 indexed merkle tree
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', 3);
+        /**
+         * Initial state:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       0       0       0        0       0       0       0
+         *  nextIdx   0       0       0       0        0       0       0       0
+         *  nextVal   0       0       0       0        0       0       0       0.
+         */
+        const INITIAL_LEAF = toBufferBE(0n, 32);
+        const initialLeafHash = pedersen.compressInputs(createIndexedTreeLeaf(0, 0, 0));
+        const level1ZeroHash = pedersen.compress(INITIAL_LEAF, INITIAL_LEAF);
+        const level2ZeroHash = pedersen.compress(level1ZeroHash, level1ZeroHash);
+        let index0Hash = initialLeafHash;
+        let e10 = pedersen.compress(index0Hash, INITIAL_LEAF);
+        let e20 = pedersen.compress(e10, level1ZeroHash);
+        const inite10 = e10;
+        const inite20 = e20;
+        let root = pedersen.compress(e20, level2ZeroHash);
+        const initialRoot = root;
+        const emptySiblingPath = new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, level2ZeroHash]);
+        const initialSiblingPath = new SiblingPath(TEST_TREE_DEPTH, [initialLeafHash, level1ZeroHash, level2ZeroHash]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+        expect(await tree.getSiblingPath(0n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, level2ZeroHash]));
+        await verifyCommittedState(tree, initialRoot, 0n, emptySiblingPath);
+        /**
+         * Add new value 30:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       30      0       0        0       0       0       0
+         *  nextIdx   1       0       0       0        0       0       0       0
+         *  nextVal   30      0       0       0        0       0       0       0.
+         */
+        index0Hash = pedersen.compressInputs(createIndexedTreeLeaf(0, 1, 30));
+        let index1Hash = pedersen.compressInputs(createIndexedTreeLeaf(30, 0, 0));
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        e20 = pedersen.compress(e10, level1ZeroHash);
+        root = pedersen.compress(e20, level2ZeroHash);
+        await tree.appendLeaves([toBufferBE(30n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(2n);
+        expect(await tree.getSiblingPath(1n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index0Hash, level1ZeroHash, level2ZeroHash]));
+        // ensure the committed state is correct
+        await verifyCommittedState(tree, initialRoot, 1n, initialSiblingPath);
+        /**
+         * Add new value 10:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       30      10      0        0       0       0       0
+         *  nextIdx   2       0       1       0        0       0       0       0
+         *  nextVal   10      0       30      0        0       0       0       0.
+         */
+        index0Hash = pedersen.compressInputs(createIndexedTreeLeaf(0, 2, 10));
+        let index2Hash = pedersen.compressInputs(createIndexedTreeLeaf(10, 1, 30));
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        let e11 = pedersen.compress(index2Hash, INITIAL_LEAF);
+        e20 = pedersen.compress(e10, e11);
+        root = pedersen.compress(e20, level2ZeroHash);
+        await tree.appendLeaves([toBufferBE(10n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(3n);
+        expect(await tree.getSiblingPath(2n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, e10, level2ZeroHash]));
+        // ensure the committed state is correct
+        await verifyCommittedState(tree, initialRoot, 2n, new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, inite10, level2ZeroHash]));
+        /**
+         * Add new value 20:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  ---------------------------------------------------------------------
+         *  val       0       30      10      20       0       0       0       0
+         *  nextIdx   2       0       3       1        0       0       0       0
+         *  nextVal   10      0       20      30       0       0       0       0.
+         */
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        index2Hash = pedersen.compressInputs(createIndexedTreeLeaf(10, 3, 20));
+        const index3Hash = pedersen.compressInputs(createIndexedTreeLeaf(20, 1, 30));
+        e11 = pedersen.compress(index2Hash, index3Hash);
+        e20 = pedersen.compress(e10, e11);
+        root = pedersen.compress(e20, level2ZeroHash);
+        await tree.appendLeaves([toBufferBE(20n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(4n);
+        expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index2Hash, e10, level2ZeroHash]));
+        // ensure the committed state is correct
+        await verifyCommittedState(tree, initialRoot, 3n, new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, inite10, level2ZeroHash]));
+        // Add 2 empty values
+        const emptyLeaves = [toBufferBE(0n, 32), toBufferBE(0n, 32)];
+        await tree.appendLeaves(emptyLeaves);
+        // The root should be the same but the size should have increased
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(6n);
+        /**
+         * Add new value 50:
+         *
+         *  index     0       1       2       3        4       5       6       7
+         *  --------------------------------------------------------------------
+         *  val       0       30      10      20       0       0       50      0
+         *  nextIdx   2       6       3       1        0       0       0       0
+         *  nextVal   10      50      20      30       0       0       0       0.
+         */
+        index1Hash = pedersen.compressInputs(createIndexedTreeLeaf(30, 6, 50));
+        const index6Hash = pedersen.compressInputs(createIndexedTreeLeaf(50, 0, 0));
+        e10 = pedersen.compress(index0Hash, index1Hash);
+        e20 = pedersen.compress(e10, e11);
+        const e13 = pedersen.compress(index6Hash, INITIAL_LEAF);
+        const e21 = pedersen.compress(level1ZeroHash, e13);
+        root = pedersen.compress(e20, e21);
+        await tree.appendLeaves([toBufferBE(50n, 32)]);
+        expect(tree.getRoot(true)).toEqual(root);
+        expect(tree.getNumLeaves(true)).toEqual(7n);
+        // ensure the committed state is correct
+        await verifyCommittedState(tree, initialRoot, 6n, new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, inite20]));
+        // // check all uncommitted hash paths
+        expect(await tree.getSiblingPath(0n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index1Hash, e11, e21]));
+        expect(await tree.getSiblingPath(1n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index0Hash, e11, e21]));
+        expect(await tree.getSiblingPath(2n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index3Hash, e10, e21]));
+        expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index2Hash, e10, e21]));
+        expect(await tree.getSiblingPath(4n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, e13, e20]));
+        expect(await tree.getSiblingPath(5n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, e13, e20]));
+        expect(await tree.getSiblingPath(6n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, e20]));
+        expect(await tree.getSiblingPath(7n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [index6Hash, level1ZeroHash, e20]));
+        // check all committed hash paths
+        expect(await tree.getSiblingPath(0n, false)).toEqual(emptySiblingPath);
+        expect(await tree.getSiblingPath(1n, false)).toEqual(initialSiblingPath);
+        expect(await tree.getSiblingPath(2n, false)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, inite10, level2ZeroHash]));
+        expect(await tree.getSiblingPath(3n, false)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, inite10, level2ZeroHash]));
+        const e2SiblingPath = new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash, inite20]);
+        expect(await tree.getSiblingPath(4n, false)).toEqual(e2SiblingPath);
+        expect(await tree.getSiblingPath(5n, false)).toEqual(e2SiblingPath);
+        expect(await tree.getSiblingPath(6n, false)).toEqual(e2SiblingPath);
+        expect(await tree.getSiblingPath(7n, false)).toEqual(e2SiblingPath);
+        await tree.commit();
+        // check all committed hash paths equal uncommitted hash paths
+        for (let i = 0; i < 8; i++) {
+            expect(await tree.getSiblingPath(BigInt(i), false)).toEqual(await tree.getSiblingPath(BigInt(i), true));
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard_indexed_tree.test.js","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.test.ts"],"names":[],"mappings":"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"}

package/dest/standard_tree/standard_tree.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AppendOnlyTree } from '../interfaces/append_only_tree.js';
+import { TreeBase } from '../tree_base.js';
+/**
+ * A Merkle tree implementation that uses a LevelDB database to store the tree.
+ */
+export declare class StandardTree extends TreeBase implements AppendOnlyTree {
+    /**
+     * Appends the given leaves to the tree.
+     * @param leaves - The leaves to append.
+     * @returns Empty promise.
+     *
+     * @remarks The batch insertion algorithm works as follows:
+     *          1. Insert all the leaves,
+     *          2. start iterating over levels from the bottom up,
+     *          3. on each level iterate over all the affected nodes (i.e. nodes whose preimages have changed),
+     *          4. fetch the preimage, hash it and insert the updated value.
+     * @remarks This algorithm is optimal when it comes to the number of hashing operations. It might not be optimal when
+     *          it comes to the number of database reads, but that should be irrelevant given that most of the time
+     *          `getLatestValueAtIndex` will return a value from cache (because at least one of the 2 children was
+     *          touched in previous iteration).
+     */
+    appendLeaves(leaves: Buffer[]): Promise<void>;
+}
+//# sourceMappingURL=standard_tree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard_tree.d.ts","sourceRoot":"","sources":["../../src/standard_tree/standard_tree.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAkB,MAAM,iBAAiB,CAAC;AAE3D;;GAEG;AACH,qBAAa,YAAa,SAAQ,QAAS,YAAW,cAAc;IAClE;;;;;;;;;;;;;;OAcG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CA+B3D"}

package/dest/standard_tree/standard_tree.js

@@ -0,0 +1,50 @@
+import { TreeBase, indexToKeyHash } from '../tree_base.js';
+/**
+ * A Merkle tree implementation that uses a LevelDB database to store the tree.
+ */
+export class StandardTree extends TreeBase {
+    /**
+     * Appends the given leaves to the tree.
+     * @param leaves - The leaves to append.
+     * @returns Empty promise.
+     *
+     * @remarks The batch insertion algorithm works as follows:
+     *          1. Insert all the leaves,
+     *          2. start iterating over levels from the bottom up,
+     *          3. on each level iterate over all the affected nodes (i.e. nodes whose preimages have changed),
+     *          4. fetch the preimage, hash it and insert the updated value.
+     * @remarks This algorithm is optimal when it comes to the number of hashing operations. It might not be optimal when
+     *          it comes to the number of database reads, but that should be irrelevant given that most of the time
+     *          `getLatestValueAtIndex` will return a value from cache (because at least one of the 2 children was
+     *          touched in previous iteration).
+     */
+    async appendLeaves(leaves) {
+        const numLeaves = this.getNumLeaves(true);
+        if (numLeaves + BigInt(leaves.length) - 1n > this.maxIndex) {
+            throw Error(`Can't append beyond max index. Max index: ${this.maxIndex}`);
+        }
+        // 1. Insert all the leaves
+        let firstIndex = numLeaves;
+        let level = this.depth;
+        for (let i = 0; i < leaves.length; i++) {
+            const cacheKey = indexToKeyHash(this.name, level, firstIndex + BigInt(i));
+            this.cache[cacheKey] = leaves[i];
+        }
+        let lastIndex = firstIndex + BigInt(leaves.length);
+        // 2. Iterate over all the levels from the bottom up
+        while (level > 0) {
+            firstIndex >>= 1n;
+            lastIndex >>= 1n;
+            // 3.Iterate over all the affected nodes at this level and update them
+            for (let index = firstIndex; index <= lastIndex; index++) {
+                const lhs = await this.getLatestValueAtIndex(level, index * 2n, true);
+                const rhs = await this.getLatestValueAtIndex(level, index * 2n + 1n, true);
+                const cacheKey = indexToKeyHash(this.name, level - 1, index);
+                this.cache[cacheKey] = this.hasher.compress(lhs, rhs);
+            }
+            level -= 1;
+        }
+        this.cachedSize = numLeaves + BigInt(leaves.length);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/standard_tree/standard_tree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=standard_tree.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard_tree.test.d.ts","sourceRoot":"","sources":["../../src/standard_tree/standard_tree.test.ts"],"names":[],"mappings":""}

package/dest/standard_tree/standard_tree.test.js

@@ -0,0 +1,58 @@
+import { CircuitsWasm } from '@aztec/circuits.js';
+import { default as levelup } from 'levelup';
+import { loadTree } from '../load_tree.js';
+import { newTree } from '../new_tree.js';
+import { standardBasedTreeTestSuite } from '../test/standard_based_test_suite.js';
+import { treeTestSuite } from '../test/test_suite.js';
+import { PedersenWithCounter } from '../test/utils/pedersen_with_counter.js';
+import { StandardTree } from './standard_tree.js';
+import { createMemDown } from '../test/utils/create_mem_down.js';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { INITIAL_LEAF } from '../tree_base.js';
+const createDb = async (levelUp, hasher, name, depth) => {
+    return await newTree(StandardTree, levelUp, hasher, name, depth);
+};
+const createFromName = async (levelUp, hasher, name) => {
+    return await loadTree(StandardTree, levelUp, hasher, name);
+};
+treeTestSuite('StandardTree', createDb, createFromName);
+standardBasedTreeTestSuite('StandardTree', createDb);
+describe('StandardTree_batchAppend', () => {
+    let wasm;
+    let pedersen;
+    beforeAll(async () => {
+        wasm = await CircuitsWasm.get();
+        pedersen = new PedersenWithCounter(wasm);
+    });
+    afterEach(() => {
+        pedersen.resetCounter();
+    });
+    it('correctly computes root when batch appending and calls compress function expected num times', async () => {
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', 3);
+        const leaves = Array.from({ length: 5 }, _ => randomBytes(32));
+        pedersen.resetCounter();
+        await tree.appendLeaves(leaves);
+        // We append 5 leaves so to update values we do the following hashing on each level:
+        //              level2Node0           level2Node1           level2Node2
+        // LEVEL2: [newLeaf0, newLeaf1], [newLeaf2, newLeaf3], [newLeaf4, INITIAL_LEAF].
+        //                    level1Node0                 level1Node1
+        // LEVEL1:    [level2Node0, level2Node1], [level2Node2, level2ZeroHash].
+        //                                       ROOT
+        // LEVEL0:                   [level1Node0, level1Node1].
+        const level2NumHashing = 3;
+        const level1NumHashing = 2;
+        const level0NumHashing = 1;
+        const expectedNumHashing = level2NumHashing + level1NumHashing + level0NumHashing;
+        expect(pedersen.compressCounter).toEqual(expectedNumHashing);
+        const level2Node0 = pedersen.compress(leaves[0], leaves[1]);
+        const level2Node1 = pedersen.compress(leaves[2], leaves[3]);
+        const level2Node2 = pedersen.compress(leaves[4], INITIAL_LEAF);
+        const level2ZeroHash = pedersen.compress(INITIAL_LEAF, INITIAL_LEAF);
+        const level1Node0 = pedersen.compress(level2Node0, level2Node1);
+        const level1Node1 = pedersen.compress(level2Node2, level2ZeroHash);
+        const root = pedersen.compress(level1Node0, level1Node1);
+        expect(tree.getRoot(true)).toEqual(root);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dest/test/standard_based_test_suite.d.ts

@@ -0,0 +1,6 @@
+import { default as levelup } from 'levelup';
+import { Hasher } from '../index.js';
+import { AppendOnlyTree } from '../interfaces/append_only_tree.js';
+import { UpdateOnlyTree } from '../interfaces/update_only_tree.js';
+export declare const standardBasedTreeTestSuite: (testName: string, createDb: (levelup: levelup.LevelUp<import("abstract-leveldown").AbstractLevelDOWN<any, any>, import("abstract-leveldown").AbstractIterator<any, any>>, hasher: Hasher, name: string, depth: number) => Promise<AppendOnlyTree | UpdateOnlyTree>) => void;
+//# sourceMappingURL=standard_based_test_suite.d.ts.map

package/dest/test/standard_based_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_based_test_suite.d.ts","sourceRoot":"","sources":["../../src/test/standard_based_test_suite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAuC,MAAM,aAAa,CAAC;AAI1E,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAMnE,eAAO,MAAM,0BAA0B,aAC3B,MAAM,kKAGN,MAAM,QACR,MAAM,SACL,MAAM,KACV,QAAQ,cAAc,GAAG,cAAc,CAAC,SAuH9C,CAAC"}