@aztec/merkle-tree 0.1.0-alpha17 → 0.1.0-alpha21

package/dest/standard_indexed_tree/test/standard_indexed_tree.test.js

@@ -0,0 +1,337 @@
+import { default as levelup } from 'levelup';
+import { INITIAL_LEAF, Pedersen, SiblingPath } from '../../index.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';
+import { StandardIndexedTreeWithAppend } from './standard_indexed_tree_with_append.js';
+const createDb = async (levelUp, hasher, name, depth, prefilledSize = 1) => {
+    return await newTree(StandardIndexedTreeWithAppend, levelUp, hasher, name, depth, prefilledSize);
+};
+const createFromName = async (levelUp, hasher, name) => {
+    return await loadTree(StandardIndexedTreeWithAppend, 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));
+        }
+    });
+    // For varying orders of insertions assert the local batch insertion generator creates the correct proofs
+    it.each([
+        // These are arbitrary but it needs to be higher than the constant `INITIAL_NULLIFIER_TREE_SIZE` and `KERNEL_NEW_NULLIFIERS_LENGTH * 2`
+        [[1003, 1002, 1001, 1000, 0, 0, 0, 0]],
+        [[1003, 1004, 1005, 1006, 0, 0, 0, 0]],
+        [[1234, 1098, 0, 0, 99999, 1096, 1054, 0]],
+        [[1970, 1980, 1040, 0, 99999, 1880, 100001, 9000000]],
+    ])('performs nullifier tree batch insertion correctly', async (nullifiers) => {
+        const leaves = nullifiers.map(i => toBufferBE(BigInt(i), 32));
+        const TREE_HEIGHT = 16; // originally from NULLIFIER_TREE_HEIGHT
+        const INITIAL_TREE_SIZE = 8; // originally from INITIAL_NULLIFIER_TREE_SIZE
+        const SUBTREE_HEIGHT = 5; // originally from BaseRollupInputs.NULLIFIER_SUBTREE_HEIGHT
+        // Create a depth-3 indexed merkle tree
+        const appendTree = await createDb(levelup(createMemDown()), pedersen, 'test', TREE_HEIGHT, INITIAL_TREE_SIZE);
+        const insertTree = await createDb(levelup(createMemDown()), pedersen, 'test', TREE_HEIGHT, INITIAL_TREE_SIZE);
+        await appendTree.appendLeaves(leaves);
+        await insertTree.batchInsert(leaves, SUBTREE_HEIGHT);
+        const expectedRoot = appendTree.getRoot(true);
+        const actualRoot = insertTree.getRoot(true);
+        expect(actualRoot).toEqual(expectedRoot);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard_indexed_tree.test.js","sourceRoot":"","sources":["../../../src/standard_indexed_tree/test/standard_indexed_tree.test.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import { StandardIndexedTree } from '../../index.js';
+/**
+ * A testing utility which is here to store the original implementation of StandardIndexedTree.appendLeaves method
+ * that was replaced by the more efficient batchInsert method. We keep the original implementation around as it useful
+ * for testing that the more complex batchInsert method works correctly.
+ */
+export declare class StandardIndexedTreeWithAppend extends StandardIndexedTree {
+    /**
+     * Appends the given leaves to the tree.
+     * @param leaves - The leaves to append.
+     * @returns Empty promise.
+     * @remarks This method is inefficient and is here mostly for testing. Use batchInsert instead.
+     */
+    appendLeaves(leaves: Buffer[]): Promise<void>;
+    /**
+     * Appends the given leaf to the tree.
+     * @param leaf - The leaf to append.
+     * @returns Empty promise.
+     */
+    private appendLeaf;
+}
+//# sourceMappingURL=standard_indexed_tree_with_append.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standard_indexed_tree_with_append.d.ts","sourceRoot":"","sources":["../../../src/standard_indexed_tree/test/standard_indexed_tree_with_append.ts"],"names":[],"mappings":";AACA,OAAO,EAAY,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE/D;;;;GAIG;AACH,qBAAa,6BAA8B,SAAQ,mBAAmB;IACpE;;;;;OAKG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1D;;;;OAIG;YACW,UAAU;CAoCzB"}

package/dest/standard_indexed_tree/test/standard_indexed_tree_with_append.js

@@ -0,0 +1,59 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { StandardIndexedTree } from '../../index.js';
+/**
+ * A testing utility which is here to store the original implementation of StandardIndexedTree.appendLeaves method
+ * that was replaced by the more efficient batchInsert method. We keep the original implementation around as it useful
+ * for testing that the more complex batchInsert method works correctly.
+ */
+export class StandardIndexedTreeWithAppend extends StandardIndexedTree {
+    /**
+     * Appends the given leaves to the tree.
+     * @param leaves - The leaves to append.
+     * @returns Empty promise.
+     * @remarks This method is inefficient and is here mostly for testing. Use batchInsert instead.
+     */
+    async appendLeaves(leaves) {
+        for (const leaf of leaves) {
+            await this.appendLeaf(leaf);
+        }
+    }
+    /**
+     * Appends the given leaf to the tree.
+     * @param leaf - The leaf to append.
+     * @returns Empty promise.
+     */
+    async appendLeaf(leaf) {
+        const newValue = toBigIntBE(leaf);
+        // Special case when appending zero
+        if (newValue === 0n) {
+            const newSize = (this.cachedSize ?? this.size) + 1n;
+            if (newSize - 1n > this.maxIndex) {
+                throw Error(`Can't append beyond max index. Max index: ${this.maxIndex}`);
+            }
+            this.cachedSize = newSize;
+            return;
+        }
+        const indexOfPrevious = this.findIndexOfPreviousValue(newValue, true);
+        const previousLeafCopy = this.getLatestLeafDataCopy(indexOfPrevious.index, true);
+        if (previousLeafCopy === undefined) {
+            throw new Error(`Previous leaf not found!`);
+        }
+        const newLeaf = {
+            value: newValue,
+            nextIndex: previousLeafCopy.nextIndex,
+            nextValue: previousLeafCopy.nextValue,
+        };
+        if (indexOfPrevious.alreadyPresent) {
+            return;
+        }
+        // insert a new leaf at the highest index and update the values of our previous leaf copy
+        const currentSize = this.getNumLeaves(true);
+        previousLeafCopy.nextIndex = BigInt(currentSize);
+        previousLeafCopy.nextValue = newLeaf.value;
+        this.cachedLeaves[Number(currentSize)] = newLeaf;
+        this.cachedLeaves[Number(indexOfPrevious.index)] = previousLeafCopy;
+        await this.updateLeaf(previousLeafCopy, BigInt(indexOfPrevious.index));
+        await this.updateLeaf(newLeaf, this.getNumLeaves(true));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfaW5kZXhlZF90cmVlX3dpdGhfYXBwZW5kLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0YW5kYXJkX2luZGV4ZWRfdHJlZS90ZXN0L3N0YW5kYXJkX2luZGV4ZWRfdHJlZV93aXRoX2FwcGVuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDN0QsT0FBTyxFQUFZLG1CQUFtQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFL0Q7Ozs7R0FJRztBQUNILE1BQU0sT0FBTyw2QkFBOEIsU0FBUSxtQkFBbUI7SUFDcEU7Ozs7O09BS0c7SUFDSSxLQUFLLENBQUMsWUFBWSxDQUFDLE1BQWdCO1FBQ3hDLEtBQUssTUFBTSxJQUFJLElBQUksTUFBTSxFQUFFO1lBQ3pCLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUM3QjtJQUNILENBQUM7SUFFRDs7OztPQUlHO0lBQ0ssS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFZO1FBQ25DLE1BQU0sUUFBUSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUVsQyxtQ0FBbUM7UUFDbkMsSUFBSSxRQUFRLEtBQUssRUFBRSxFQUFFO1lBQ25CLE1BQU0sT0FBTyxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1lBQ3BELElBQUksT0FBTyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFO2dCQUNoQyxNQUFNLEtBQUssQ0FBQyw2Q0FBNkMsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7YUFDM0U7WUFDRCxJQUFJLENBQUMsVUFBVSxHQUFHLE9BQU8sQ0FBQztZQUMxQixPQUFPO1NBQ1I7UUFFRCxNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMsd0JBQXdCLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ3RFLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFFakYsSUFBSSxnQkFBZ0IsS0FBSyxTQUFTLEVBQUU7WUFDbEMsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO1NBQzdDO1FBQ0QsTUFBTSxPQUFPLEdBQUc7WUFDZCxLQUFLLEVBQUUsUUFBUTtZQUNmLFNBQVMsRUFBRSxnQkFBZ0IsQ0FBQyxTQUFTO1lBQ3JDLFNBQVMsRUFBRSxnQkFBZ0IsQ0FBQyxTQUFTO1NBQzFCLENBQUM7UUFDZCxJQUFJLGVBQWUsQ0FBQyxjQUFjLEVBQUU7WUFDbEMsT0FBTztTQUNSO1FBQ0QseUZBQXlGO1FBQ3pGLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDNUMsZ0JBQWdCLENBQUMsU0FBUyxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUNqRCxnQkFBZ0IsQ0FBQyxTQUFTLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQztRQUMzQyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxHQUFHLE9BQU8sQ0FBQztRQUNqRCxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQztRQUNwRSxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsZ0JBQWdCLEVBQUUsTUFBTSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1FBQ3ZFLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzFELENBQUM7Q0FDRiJ9

package/dest/standard_tree/standard_tree.d.ts

@@ -9,16 +9,6 @@ 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>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"standard_tree.d.ts","sourceRoot":"","sources":["../../src/standard_tree/standard_tree.ts"],"names":[],"mappings":";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"}
+{"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,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;GAEG;AACH,qBAAa,YAAa,SAAQ,QAAS,YAAW,cAAc;IAClE;;;;OAIG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3D"}

package/dest/standard_tree/standard_tree.js

@@ -1,4 +1,4 @@
-import { TreeBase, indexToKeyHash } from '../tree_base.js';
+import { TreeBase } from '../tree_base.js';
 /**
  * A Merkle tree implementation that uses a LevelDB database to store the tree.
  */
@@ -7,44 +7,9 @@ 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);
+        await super.appendLeaves(leaves);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhbmRhcmRfdHJlZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdGFuZGFyZF90cmVlL3N0YW5kYXJkX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTNDOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFlBQWEsU0FBUSxRQUFRO0lBQ3hDOzs7O09BSUc7SUFDSSxLQUFLLENBQUMsWUFBWSxDQUFDLE1BQWdCO1FBQ3hDLE1BQU0sS0FBSyxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNuQyxDQUFDO0NBQ0YifQ==

package/dest/tree_base.d.ts

@@ -3,7 +3,6 @@ import { LevelUp, LevelUpChain } from 'levelup';
 import { SiblingPath } from './sibling_path/sibling_path.js';
 import { Hasher } from './hasher.js';
 import { MerkleTree } from './interfaces/merkle_tree.js';
-export declare const indexToKeyHash: (name: string, level: number, index: bigint) => string;
 export declare const decodeMeta: (meta: Buffer) => {
     root: Buffer;
     depth: number;
@@ -16,26 +15,24 @@ export declare const INITIAL_LEAF: Buffer;
 export declare abstract class TreeBase implements MerkleTree {
     protected db: LevelUp;
     protected hasher: Hasher;
-    protected name: string;
-    protected depth: number;
+    private name;
+    private depth;
     protected size: bigint;
     protected readonly maxIndex: bigint;
     protected cachedSize?: bigint;
     private root;
     private zeroHashes;
-    protected cache: {
-        [key: string]: Buffer;
-    };
+    private cache;
     constructor(db: LevelUp, hasher: Hasher, name: string, depth: number, size?: bigint, root?: Buffer);
     /**
      * Returns the root of the tree.
-     * @param includeUncommitted - If true, root incorporating uncomitted changes is returned.
+     * @param includeUncommitted - If true, root incorporating uncommitted changes is returned.
      * @returns The root of the tree.
      */
     getRoot(includeUncommitted: boolean): Buffer;
     /**
      * Returns the number of leaves in the tree.
-     * @param includeUncommitted - If true, the returned number of leaves includes uncomitted changes.
+     * @param includeUncommitted - If true, the returned number of leaves includes uncommitted changes.
      * @returns The number of leaves in the tree.
      */
     getNumLeaves(includeUncommitted: boolean): bigint;
@@ -92,7 +89,7 @@ export declare abstract class TreeBase implements MerkleTree {
      * @returns The latest value at the given index.
      * Note: If the value is not in the cache, it will be fetched from the database.
      */
-    protected getLatestValueAtIndex(level: number, index: bigint, includeUncommitted: boolean): Promise<Buffer>;
+    private getLatestValueAtIndex;
     /**
      * Gets a value from db by key.
      * @param key - The key to by which to get the value.
@@ -114,5 +111,21 @@ export declare abstract class TreeBase implements MerkleTree {
      * @param batch - The batch to which to write the meta data.
      */
     protected writeMeta(batch?: LevelUpChain<string, Buffer>): Promise<void>;
+    /**
+     * 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).
+     */
+    protected appendLeaves(leaves: Buffer[]): Promise<void>;
 }
 //# sourceMappingURL=tree_base.d.ts.map