@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/avm/avm_tree.js

@@ -1,684 +0,0 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
-import { AppendOnlyTreeSnapshot, NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/circuits.js';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { strict as assert } from 'assert';
-import cloneDeep from 'lodash.clonedeep';
-const MAX_TREE_DEPTH = 128;
-/**
- * Helper function to precompute zero hashes
- */
-async function preComputeZeroHashes() {
-    let currentHash = Fr.zero();
-    const zeroHashes = [];
-    for (let i = 0; i < MAX_TREE_DEPTH; i++) {
-        zeroHashes.push(currentHash);
-        currentHash = await poseidon2Hash([currentHash, currentHash]);
-    }
-    return zeroHashes;
-}
-/****************************************************/
-/****** The AvmEphemeralForest Class ****************/
-/****************************************************/
-/**
- * This provides a forkable abstraction over the EphemeralAvmTree class
- *  It contains the logic to look up into a read-only MerkleTreeDb to discover
- *  the sibling paths and low witnesses that weren't inserted as part of this tx
- */
-export class AvmEphemeralForest {
-    constructor(treeDb, treeMap, 
-    // This contains the [leaf index,indexed leaf preimages] tuple that were updated or inserted in the ephemeral tree
-    // This is needed since we have a sparse collection of keys sorted leaves in the ephemeral tree
-    indexedUpdates, indexedSortedKeys) {
-        this.treeDb = treeDb;
-        this.treeMap = treeMap;
-        this.indexedUpdates = indexedUpdates;
-        this.indexedSortedKeys = indexedSortedKeys;
-    }
-    static async create(treeDb) {
-        const treeMap = new Map();
-        for (const treeType of [MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.PUBLIC_DATA_TREE]) {
-            const treeInfo = await treeDb.getTreeInfo(treeType);
-            const tree = await EphemeralAvmTree.create(treeInfo.size, treeInfo.depth, treeDb, treeType);
-            treeMap.set(treeType, tree);
-        }
-        const indexedSortedKeys = new Map();
-        indexedSortedKeys.set(MerkleTreeId.NULLIFIER_TREE, []);
-        indexedSortedKeys.set(MerkleTreeId.PUBLIC_DATA_TREE, []);
-        return new AvmEphemeralForest(treeDb, treeMap, new Map(), indexedSortedKeys);
-    }
-    fork() {
-        return new AvmEphemeralForest(this.treeDb, cloneDeep(this.treeMap), cloneDeep(this.indexedUpdates), cloneDeep(this.indexedSortedKeys));
-    }
-    /**
-     * Gets sibling path for a leaf - if the sibling path is not found in the tree, it is fetched from the DB
-     * @param treeId - The tree to be queried for a sibling path.
-     * @param index - The index of the leaf for which a sibling path should be returned.
-     * @returns The sibling path of the leaf.
-     */
-    async getSiblingPath(treeId, index) {
-        const tree = this.treeMap.get(treeId);
-        let path = await tree.getSiblingPath(index);
-        if (path === undefined) {
-            // We dont have the sibling path in our tree - we have to get it from the DB
-            path = (await this.treeDb.getSiblingPath(treeId, index)).toFields();
-            // Since the sibling path could be outdated, we compare it with nodes in our tree
-            // if we encounter a mismatch, we replace it with the node we found in our tree.
-            for (let i = 0; i < path.length; i++) {
-                const siblingIndex = index ^ 1n;
-                const node = tree.getNode(siblingIndex, tree.depth - i);
-                if (node !== undefined) {
-                    const nodeHash = await tree.hashTree(node, i + 1);
-                    if (!nodeHash.equals(path[i])) {
-                        path[i] = nodeHash;
-                    }
-                }
-                index >>= 1n;
-            }
-        }
-        return path;
-    }
-    /**
-     * This does the work of appending the new leaf and updating the low witness
-     * @param treeId - The tree to be queried for a sibling path.
-     * @param lowWitnessIndex - The index of the low leaf in the tree.
-     * @param lowWitness - The preimage of the low leaf.
-     * @param newLeafPreimage - The preimage of the new leaf to be inserted.
-     * @returns The sibling path of the new leaf (i.e. the insertion path)
-     */
-    async appendIndexedTree(treeId, lowLeafIndex, lowLeafPreimage, newLeafPreimage) {
-        const tree = this.treeMap.get(treeId);
-        const newLeaf = await this.hashPreimage(newLeafPreimage);
-        const insertIndex = tree.leafCount;
-        const lowLeaf = await this.hashPreimage(lowLeafPreimage);
-        // Update the low nullifier hash
-        this.setIndexedUpdates(treeId, lowLeafIndex, lowLeafPreimage);
-        tree.updateLeaf(lowLeaf, lowLeafIndex);
-        // Append the new leaf
-        tree.appendLeaf(newLeaf);
-        this.setIndexedUpdates(treeId, insertIndex, newLeafPreimage);
-        return (await tree.getSiblingPath(insertIndex));
-    }
-    /**
-     * This writes or updates a slot in the public data tree with a value
-     * @param slot - The slot to be written to.
-     * @param newValue - The value to be written or updated to
-     * @returns The insertion result which contains the insertion path, low leaf and the new leaf index
-     */
-    async writePublicStorage(slot, newValue) {
-        // This only works for the public data tree
-        const treeId = MerkleTreeId.PUBLIC_DATA_TREE;
-        const tree = this.treeMap.get(treeId);
-        const [leafOrLowLeafInfo, pathAbsentInEphemeralTree] = await this._getLeafOrLowLeafInfo(treeId, slot);
-        const { preimage, index: lowLeafIndex, alreadyPresent: update } = leafOrLowLeafInfo;
-        const siblingPath = await this.getSiblingPath(treeId, lowLeafIndex);
-        if (pathAbsentInEphemeralTree) {
-            // Since we have never seen this before - we should insert it into our tree as it is about to be updated.
-            this.treeMap.get(treeId).insertSiblingPath(lowLeafIndex, siblingPath);
-        }
-        if (update) {
-            const updatedPreimage = cloneDeep(preimage);
-            const existingPublicDataSiblingPath = siblingPath;
-            updatedPreimage.value = newValue;
-            tree.updateLeaf(await this.hashPreimage(updatedPreimage), lowLeafIndex);
-            this.setIndexedUpdates(treeId, lowLeafIndex, updatedPreimage);
-            this._updateSortedKeys(treeId, [updatedPreimage.slot], [lowLeafIndex]);
-            return {
-                element: updatedPreimage,
-                lowWitness: {
-                    preimage: preimage,
-                    index: lowLeafIndex,
-                    siblingPath: existingPublicDataSiblingPath,
-                },
-                update: true,
-            };
-        }
-        // We are writing to a new slot, so our preimage is a lowNullifier
-        const insertionIndex = tree.leafCount;
-        const updatedLowLeaf = cloneDeep(preimage);
-        updatedLowLeaf.nextSlot = slot;
-        updatedLowLeaf.nextIndex = insertionIndex;
-        const newPublicDataLeaf = new PublicDataTreeLeafPreimage(slot, newValue, new Fr(preimage.getNextKey()), preimage.getNextIndex());
-        const insertionPath = await this.appendIndexedTree(treeId, lowLeafIndex, updatedLowLeaf, newPublicDataLeaf);
-        // Even though the low leaf key is not updated, we still need to update the sorted keys in case we have
-        // not seen the low leaf before
-        this._updateSortedKeys(treeId, [newPublicDataLeaf.slot, updatedLowLeaf.slot], [insertionIndex, lowLeafIndex]);
-        return {
-            element: newPublicDataLeaf,
-            lowWitness: {
-                preimage,
-                index: lowLeafIndex,
-                siblingPath,
-            },
-            update: false,
-            leafIndex: insertionIndex,
-            insertionPath: insertionPath,
-        };
-    }
-    _updateSortedKeys(treeId, keys, index) {
-        // This is a reference
-        const existingKeyVector = this.indexedSortedKeys.get(treeId);
-        // Should already be sorted so not need to re-sort if we just update or splice
-        for (let i = 0; i < keys.length; i++) {
-            const foundIndex = existingKeyVector.findIndex(x => x[1] === index[i]);
-            if (foundIndex === -1) {
-                // New element, we splice it into the correct location
-                const spliceIndex = indexOrNextLowestInArray(keys[i], existingKeyVector.map(x => x[0])) + 1;
-                existingKeyVector.splice(spliceIndex, 0, [keys[i], index[i]]);
-            }
-            else {
-                // Update the existing element
-                existingKeyVector[foundIndex][0] = keys[i];
-            }
-        }
-    }
-    /**
-     * This appends a nullifier to the nullifier tree, and throws if the nullifier already exists
-     * @param value - The nullifier to be appended
-     * @returns The insertion result which contains the insertion path, low leaf and the new leaf index
-     */
-    async appendNullifier(nullifier) {
-        const treeId = MerkleTreeId.NULLIFIER_TREE;
-        const tree = this.treeMap.get(treeId);
-        const [leafOrLowLeafInfo, pathAbsentInEphemeralTree] = await this._getLeafOrLowLeafInfo(treeId, nullifier);
-        const { preimage, index, alreadyPresent } = leafOrLowLeafInfo;
-        const siblingPath = await this.getSiblingPath(treeId, index);
-        if (pathAbsentInEphemeralTree) {
-            // Since we have never seen this before - we should insert it into our tree as it is about to be updated.
-            this.treeMap.get(treeId).insertSiblingPath(index, siblingPath);
-        }
-        assert(!alreadyPresent, 'Nullifier already exists in the tree. Cannot update a nullifier!');
-        // We are writing a new entry
-        const insertionIndex = tree.leafCount;
-        const updatedLowNullifier = cloneDeep(preimage);
-        updatedLowNullifier.nextNullifier = nullifier;
-        updatedLowNullifier.nextIndex = insertionIndex;
-        const newNullifierLeaf = new NullifierLeafPreimage(nullifier, preimage.nextNullifier, preimage.nextIndex);
-        const insertionPath = await this.appendIndexedTree(treeId, index, updatedLowNullifier, newNullifierLeaf);
-        // Even though the low nullifier key is not updated, we still need to update the sorted keys in case we have
-        // not seen the low nullifier before
-        this._updateSortedKeys(treeId, [newNullifierLeaf.nullifier, updatedLowNullifier.nullifier], [insertionIndex, index]);
-        return {
-            element: newNullifierLeaf,
-            lowWitness: {
-                preimage,
-                index,
-                siblingPath,
-            },
-            leafIndex: insertionIndex,
-            insertionPath: insertionPath,
-        };
-    }
-    /**
-     * This appends a note hash to the note hash tree
-     * @param value - The note hash to be appended
-     * @returns The insertion result which contains the insertion path
-     */
-    async appendNoteHash(noteHash) {
-        const tree = this.treeMap.get(MerkleTreeId.NOTE_HASH_TREE);
-        tree.appendLeaf(noteHash);
-        // We use leafCount - 1 here because we would have just appended a leaf
-        const insertionPath = await tree.getSiblingPath(tree.leafCount - 1n);
-        return insertionPath;
-    }
-    /**
-     * This is wrapper around treeId to set values in the indexedUpdates map
-     */
-    setIndexedUpdates(treeId, index, preimage) {
-        let updates = this.indexedUpdates.get(treeId);
-        if (updates === undefined) {
-            updates = new Map();
-            this.indexedUpdates.set(treeId, updates);
-        }
-        updates.set(index, preimage);
-    }
-    /**
-     * This is wrapper around treeId to get values in the indexedUpdates map.
-     * Should only be called if we know the value exists.
-     */
-    getIndexedUpdate(treeId, index) {
-        const updates = this.indexedUpdates.get(treeId);
-        assert(updates !== undefined, `No updates exist in the ephemeral ${MerkleTreeId[treeId]} tree.`);
-        const preimage = updates.get(index);
-        assert(updates !== undefined, `No update exists in the ephemeral ${MerkleTreeId[treeId]} tree for leafIndex ${index}.`);
-        return preimage;
-    }
-    /**
-     * This is wrapper around treeId to check membership (i.e. has()) of index in the indexedUpdates map
-     */
-    hasLocalUpdates(treeId, index) {
-        const updates = this.indexedUpdates.get(treeId);
-        if (updates === undefined) {
-            return false;
-        }
-        return updates.has(index);
-    }
-    /**
-     * Get the leaf or low leaf preimage and its index in the indexed tree given a key (slot or nullifier value).
-     * If the key is not found in the tree, it does an external lookup to the underlying merkle DB.
-     * @param treeId - The tree we are looking up in
-     * @param key - The key for which we are look up the leaf or low leaf for.
-     * @param T - The type of the preimage (PublicData or Nullifier)
-     * @returns The leaf or low leaf info (preimage & leaf index).
-     */
-    async getLeafOrLowLeafInfo(treeId, key) {
-        const [leafOrLowLeafInfo, _] = await this._getLeafOrLowLeafInfo(treeId, key);
-        return leafOrLowLeafInfo;
-    }
-    /**
-     * Internal helper to get the leaf or low leaf preimage and its index in the indexed tree given a key (slot or nullifier value).
-     * If the key is not found in the tree, it does an external lookup to the underlying merkle DB.
-     * Indicates whethe the sibling path is absent in the ephemeral tree.
-     * @param treeId - The tree we are looking up in
-     * @param key - The key for which we are look up the leaf or low leaf for.
-     * @param T - The type of the preimage (PublicData or Nullifier)
-     * @returns [
-     *     getLeafResult - The leaf or low leaf info (preimage & leaf index),
-     *     pathAbsentInEphemeralTree - whether its sibling path is absent in the ephemeral tree (useful during insertions)
-     * ]
-     */
-    async _getLeafOrLowLeafInfo(treeId, key) {
-        const bigIntKey = key.toBigInt();
-        // In this function, "min" refers to the leaf with the
-        // largest key <= the specified key in the indexedUpdates.
-        // In other words, the leaf with the "next lowest" key in indexedUpdates.
-        // First, search the indexed updates (no DB fallback) to find
-        // the leafIndex of the leaf with the largest key <= the specified key.
-        const minIndexedLeafIndex = this._getLeafIndexOrNextLowestInIndexedUpdates(treeId, key);
-        // Then we search on the external DB
-        const leafOrLowLeafWitnessFromExternalDb = await this._getLeafOrLowLeafWitnessInExternalDb(treeId, bigIntKey);
-        // If the indexed updates are empty, we can return the leaf from the DB
-        if (minIndexedLeafIndex === -1n) {
-            return [leafOrLowLeafWitnessFromExternalDb, /*pathAbsentInEphemeralTree=*/ true];
-        }
-        // Otherwise, we return the closest one. First fetch the leaf from the indexed updates.
-        const minIndexedUpdate = this.getIndexedUpdate(treeId, minIndexedLeafIndex);
-        // And get both keys
-        const keyFromIndexed = minIndexedUpdate.getKey();
-        const keyFromExternal = leafOrLowLeafWitnessFromExternalDb.preimage.getKey();
-        if (keyFromExternal > keyFromIndexed) {
-            // this.log.debug(`Using leaf from external DB for ${MerkleTreeId[treeId]}`);
-            return [leafOrLowLeafWitnessFromExternalDb, /*pathAbsentInEphemeralTree=*/ true];
-        }
-        else {
-            // this.log.debug(`Using leaf from indexed DB for ${MerkleTreeId[treeId]}`);
-            const leafInfo = {
-                preimage: minIndexedUpdate,
-                index: minIndexedLeafIndex,
-                alreadyPresent: keyFromIndexed === bigIntKey,
-            };
-            return [leafInfo, /*pathAbsentInEphemeralTree=*/ false];
-        }
-    }
-    /**
-     * Helper to search for the leaf with the specified key in the indexedUpdates
-     * and return its leafIndex.
-     * If not present, return the leafIndex of the largest leaf <= the specified key
-     * (the leafIndex of the next lowest key).
-     *
-     * If no entry exists in indexedUpdates <= the specified key, return -1.
-     * @returns - The leafIndex of the leaf with the largest key <= the specified key.
-     */
-    _getLeafIndexOrNextLowestInIndexedUpdates(treeId, key) {
-        const keyOrderedVector = this.indexedSortedKeys.get(treeId);
-        const indexInVector = indexOrNextLowestInArray(key, keyOrderedVector.map(x => x[0]));
-        if (indexInVector !== -1) {
-            const [_, leafIndex] = keyOrderedVector[indexInVector];
-            return leafIndex;
-        }
-        else {
-            // no leaf <= the specified key was found
-            return -1n;
-        }
-    }
-    /**
-     * Query the external DB to get leaf if present, low leaf if absent
-     */
-    async _getLeafOrLowLeafWitnessInExternalDb(treeId, key) {
-        // "key" is siloed slot (leafSlot) or siloed nullifier
-        const previousValueIndex = await this.treeDb.getPreviousValueIndex(treeId, key);
-        assert(previousValueIndex !== undefined, `${MerkleTreeId[treeId]} low leaf index should always be found (even if target leaf does not exist)`);
-        const { index: leafIndex, alreadyPresent } = previousValueIndex;
-        const leafPreimage = await this.treeDb.getLeafPreimage(treeId, leafIndex);
-        assert(leafPreimage !== undefined, `${MerkleTreeId[treeId]}  low leaf preimage should never be undefined (even if target leaf does not exist)`);
-        return { preimage: leafPreimage, index: leafIndex, alreadyPresent };
-    }
-    /**
-     * This hashes the preimage to a field element
-     */
-    hashPreimage(preimage) {
-        const input = preimage.toHashInputs().map(x => Fr.fromBuffer(x));
-        return poseidon2Hash(input);
-    }
-    async getTreeSnapshot(id) {
-        const tree = this.treeMap.get(id);
-        const root = await tree.getRoot();
-        return new AppendOnlyTreeSnapshot(root, Number(tree.leafCount));
-    }
-}
-/****************************************************/
-/****** Some useful Structs and Enums **************/
-/****************************************************/
-var TreeType;
-(function (TreeType) {
-    TreeType[TreeType["LEAF"] = 0] = "LEAF";
-    TreeType[TreeType["NODE"] = 1] = "NODE";
-})(TreeType || (TreeType = {}));
-var SiblingStatus;
-(function (SiblingStatus) {
-    SiblingStatus[SiblingStatus["MEMBER"] = 0] = "MEMBER";
-    SiblingStatus[SiblingStatus["NONMEMBER"] = 1] = "NONMEMBER";
-    SiblingStatus[SiblingStatus["ERROR"] = 2] = "ERROR";
-})(SiblingStatus || (SiblingStatus = {}));
-/****************************************************/
-/****** Some Helpful Constructors for Trees  ********/
-/****************************************************/
-const Node = (left, right) => ({
-    tag: TreeType.NODE,
-    leftTree: left,
-    rightTree: right,
-});
-const Leaf = (value) => ({
-    tag: TreeType.LEAF,
-    value,
-});
-/****************************************************/
-/****** The EphemeralAvmTree Class *****************/
-/****************************************************/
-/**
- * This class contains a recursively defined tree that has leaves at different heights
- * It is seeded by an existing merkle treeDb for which it derives a frontier
- * It is intended to be a lightweight tree that contains only the necessary information to suppport appends or updates
- */
-export class EphemeralAvmTree {
-    constructor(root, leafCount, depth, zeroHashes) {
-        this.root = root;
-        this.leafCount = leafCount;
-        this.depth = depth;
-        this.zeroHashes = zeroHashes;
-        this.tree = root;
-        this.frontier = [];
-    }
-    static async create(forkedLeafCount, depth, treeDb, merkleId) {
-        let zeroHashes = EphemeralAvmTree.precomputedZeroHashes;
-        if (zeroHashes === undefined) {
-            zeroHashes = await preComputeZeroHashes();
-            EphemeralAvmTree.precomputedZeroHashes = zeroHashes;
-        }
-        const zeroHash = zeroHashes[depth];
-        const tree = new EphemeralAvmTree(Leaf(zeroHash), forkedLeafCount, depth, zeroHashes);
-        await tree.initializeFrontier(treeDb, merkleId);
-        return tree;
-    }
-    /**
-     * This is a recursive function that inserts a leaf into the tree
-     * @param value - The value of the leaf to be inserted
-     */
-    appendLeaf(value) {
-        const insertPath = this._derivePathLE(this.leafCount);
-        this.tree = this._insertLeaf(value, insertPath, this.depth, this.tree);
-        this.leafCount++;
-    }
-    /**
-     * This is a recursive function that upserts a leaf into the tree at a index and depth
-     * @param value - The value of the leaf to be inserted
-     * @param index - The index of the leaf to be inserted
-     * @param depth - The depth of the leaf to be inserted (defaults to the bottom of the tree)
-     */
-    updateLeaf(value, index, depth = this.depth) {
-        const insertPath = this._derivePathLE(index, depth);
-        this.tree = this._insertLeaf(value, insertPath, depth, this.tree);
-    }
-    /**
-     * Get the sibling path of a leaf in the tree
-     * @param index - The index of the leaf for which a sibling path should be returned.
-     * @returns The sibling path of the leaf, can fail if the path is not found
-     */
-    async getSiblingPath(index) {
-        const searchPath = this._derivePathLE(index);
-        // Handle cases where we error out
-        const { path, status } = await this._getSiblingPath(searchPath, this.tree, []);
-        if (status === SiblingStatus.ERROR) {
-            return undefined;
-        }
-        return path;
-    }
-    /**
-     * This upserts the nodes of the sibling path into the tree
-     * @param index - The index of the leaf that the sibling path is derived from
-     * @param siblingPath - The sibling path of the index
-     */
-    insertSiblingPath(index, siblingPath) {
-        for (let i = 0; i < siblingPath.length; i++) {
-            // Flip(XOR) the last bit because we are inserting siblings of the leaf
-            const sibIndex = index ^ 1n;
-            const node = this.getNode(sibIndex, this.depth - i);
-            // If we are inserting a sibling path and we already have a branch at that index in our
-            // ephemeral tree, we should not overwrite it
-            if (node === undefined || node.tag === TreeType.LEAF) {
-                this.updateLeaf(siblingPath[i], sibIndex, this.depth - i);
-            }
-            index >>= 1n;
-        }
-    }
-    /**
-     * This is a helper function that computes the index of the frontier nodes at each depth
-     * @param leafCount - The number of leaves in the tree
-     * @returns An array of frontier indices at each depth, sorted from leaf to root
-     */
-    // Do we really need LeafCount to be a bigint - log2 is on numbers only
-    static computeFrontierLeafIndices(leafCount) {
-        const numFrontierEntries = Math.floor(Math.log2(leafCount)) + 1;
-        const frontierIndices = [];
-        for (let i = 0; i < numFrontierEntries; i++) {
-            if (leafCount === 0) {
-                frontierIndices.push(0);
-            }
-            else if (leafCount % 2 === 0) {
-                frontierIndices.push(leafCount - 2);
-            }
-            else {
-                frontierIndices.push(leafCount - 1);
-            }
-            leafCount >>= 1;
-        }
-        return frontierIndices;
-    }
-    /**
-     * This derives the frontier and inserts them into the tree
-     * @param treeDb - The treeDb to be queried for sibling paths
-     * @param merkleId - The treeId of the tree to be queried for sibling paths
-     */
-    async initializeFrontier(treeDb, merkleId) {
-        // The frontier indices are sorted from the leaf to root
-        const frontierIndices = EphemeralAvmTree.computeFrontierLeafIndices(Number(this.leafCount));
-        // The frontier indices are level-based - i.e. index N at level L.
-        // Since we can only ask the DB for paths from the root to the leaf, we do the following complicated calculations
-        // 1) The goal is to insert the frontier node N at level L into the tree.
-        // 2) We get the path to a leaf that passes through the frontier node we want (there are multiple paths so we just pick one)
-        // 3) We can only get sibling paths from the root to the leaf, so we get the sibling path of the leaf from (2)
-        // NOTE: This is terribly inefficient and we should probably change the DB API to allow for getting paths to a node
-        const frontierValues = [];
-        // These are leaf indexes that pass through the frontier nodes
-        for (let i = 0; i < frontierIndices.length; i++) {
-            // Given the index to a frontier, we first xor it so we can get its sibling index at depth L
-            // We then extend the path to that sibling index by shifting left the requisite number of times (for simplicity we just go left down the tree - it doesnt matter)
-            // This provides us the leaf index such that if we ask for this leafIndex's sibling path, it will pass through the frontier node
-            const index = BigInt(frontierIndices[i] ^ 1) << BigInt(i);
-            // This path passes through our frontier node at depth - i
-            const path = await treeDb.getSiblingPath(merkleId, index);
-            // We derive the path that we can walk and truncate it so that it terminates exactly at the frontier node
-            const frontierPath = this._derivePathLE(BigInt(frontierIndices[i]), this.depth - i);
-            // The value of the frontier is the at the i-th index of the sibling path
-            const frontierValue = path.toFields()[i];
-            frontierValues.push(frontierValue);
-            // We insert it at depth - i (the truncated position)
-            // Note this is a leaf node that wont necessarily be at the bottom of the tree (besides the first frontier)
-            this.tree = this._insertLeaf(frontierValue, frontierPath, this.depth - i, this.tree);
-        }
-        this.frontier = frontierValues;
-    }
-    /**
-     * Computes the root of the tree
-     */
-    getRoot() {
-        return this.hashTree(this.tree, this.depth);
-    }
-    /**
-     * Recursively hashes the subtree
-     * @param tree - The tree to be hashed
-     * @param depth - The depth of the tree
-     */
-    async hashTree(tree, depth) {
-        switch (tree.tag) {
-            case TreeType.NODE: {
-                return poseidon2Hash([
-                    await this.hashTree(tree.leftTree, depth - 1),
-                    await this.hashTree(tree.rightTree, depth - 1),
-                ]);
-            }
-            case TreeType.LEAF: {
-                return tree.value;
-            }
-        }
-    }
-    /**
-     * Extracts the subtree from a given index and depth
-     * @param index - The index of the node to be extracted
-     * @param depth - The depth of the node to be extracted
-     * @returns The subtree rooted at the index and depth
-     */
-    getNode(index, depth) {
-        const path = this._derivePathBE(index, depth);
-        const truncatedPath = path.slice(0, depth);
-        truncatedPath.reverse();
-        try {
-            return this._getNode(truncatedPath, this.tree);
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    /**
-     * This is the recursive helper for getNode
-     */
-    _getNode(nodePath, tree) {
-        if (nodePath.length === 0) {
-            return tree;
-        }
-        switch (tree.tag) {
-            case TreeType.NODE:
-                return nodePath.pop() === 0 ? this._getNode(nodePath, tree.leftTree) : this._getNode(nodePath, tree.rightTree);
-            case TreeType.LEAF:
-                throw new Error('Node not found');
-        }
-    }
-    /** Our tree traversal uses an array of 1s and 0s to represent the path to a leaf and expects them to be in LE order
-     * This helps with deriving it given an index and (optionally a depth)
-     * @param index - The index to derive a path to within the tree, does not have to terminate at a leaf
-     * @param depth - The depth to traverse, if not provided it will traverse to the bottom of the tree
-     * @returns The path to the leaf in LE order
-     */
-    _derivePathLE(index, depth = this.depth) {
-        return this._derivePathBE(index, depth).reverse();
-    }
-    /** Sometimes we want it in BE order, to make truncating easier
-     * @param index - The index to derive a path to within the tree, does not have to terminate at a leaf
-     * @param depth - The depth to traverse, if not provided it will traverse to the bottom of the tree
-     * @returns The path to the leaf in LE order
-     */
-    _derivePathBE(index, depth = this.depth) {
-        return index
-            .toString(2)
-            .padStart(depth, '0')
-            .split('')
-            .map(x => parseInt(x));
-    }
-    /**
-     * This is a recursive function that upserts a leaf into the tree given a path
-     * @param value - The value of the leaf to be upserted
-     * @param insertPath - The path to the leaf, this should be ordered from leaf to root (i.e. LE encoded)
-     * @param depth - The depth of the tree
-     * @param tree - The current tree
-     * @param appendMode - If true we append the relevant zeroHashes to the tree as we traverse
-     */
-    _insertLeaf(value, insertPath, depth, tree) {
-        if (insertPath.length > this.depth || depth > this.depth) {
-            throw new Error('PATH EXCEEDS DEPTH');
-        }
-        if (depth === 0 || insertPath.length === 0) {
-            return Leaf(value);
-        }
-        switch (tree.tag) {
-            case TreeType.NODE: {
-                return insertPath.pop() === 0
-                    ? Node(this._insertLeaf(value, insertPath, depth - 1, tree.leftTree), tree.rightTree)
-                    : Node(tree.leftTree, this._insertLeaf(value, insertPath, depth - 1, tree.rightTree));
-            }
-            case TreeType.LEAF: {
-                const zeroLeaf = Leaf(this.zeroHashes[depth - 1]);
-                return insertPath.pop() === 0
-                    ? Node(this._insertLeaf(value, insertPath, depth - 1, zeroLeaf), zeroLeaf)
-                    : Node(zeroLeaf, this._insertLeaf(value, insertPath, depth - 1, zeroLeaf));
-            }
-        }
-    }
-    /* Recursive helper for getSiblingPath, this only looks inside the tree and does not resolve using
-     * a DB. If a path is not found, it returns an error status that is expected to be handled by the caller
-     * @param searchPath - The path to the leaf for which we would like the sibling pathin LE order
-     * @param tree - The current tree
-     * @param acc - The accumulated sibling path
-     */
-    async _getSiblingPath(searchPath, tree, acc) {
-        // If we have reached the end of the path, we should be at a leaf or empty node
-        // If it is a leaf, we check if the value is equal to the leaf value
-        // If it is empty we check if the value is equal to zero
-        if (searchPath.length === 0) {
-            switch (tree.tag) {
-                case TreeType.LEAF:
-                    return { path: acc, status: SiblingStatus.MEMBER };
-                case TreeType.NODE:
-                    return { path: [], status: SiblingStatus.ERROR };
-            }
-        }
-        // Keep exploring here
-        switch (tree.tag) {
-            case TreeType.NODE: {
-                // Look at the next element of the path to decided if we go left or right, note this mutates!
-                return searchPath.pop() === 0
-                    ? await this._getSiblingPath(searchPath, tree.leftTree, [await this.hashTree(tree.rightTree, searchPath.length)].concat(acc))
-                    : await this._getSiblingPath(searchPath, tree.rightTree, [await this.hashTree(tree.leftTree, searchPath.length)].concat(acc));
-            }
-            // In these two situations we are exploring a subtree we dont have information about
-            // We should return an error and look inside the DB
-            case TreeType.LEAF:
-                return { path: [], status: SiblingStatus.ERROR };
-        }
-    }
-}
-/**
- * Return the index of the key in the array, or index-1 if they key is not found.
- */
-function indexOrNextLowestInArray(key, arr) {
-    // We are looking for the index of the largest element in the array that is less than the key
-    let start = 0;
-    let end = arr.length;
-    // Note that the easiest way is to increment the search key by 1 and then do a binary search
-    const keyPlus1 = key.add(Fr.ONE);
-    while (start < end) {
-        const mid = Math.floor((start + end) / 2);
-        if (arr[mid].cmp(keyPlus1) < 0) {
-            // The key + 1 is greater than the midpoint, so we can continue searching the top half
-            start = mid + 1;
-        }
-        else {
-            // The key + 1 is LT or EQ the arr element, so we can continue searching the bottom half
-            end = mid;
-        }
-    }
-    // We either found key + 1 or start is now at the index of the largest element that we would have inserted key + 1
-    // Therefore start - 1 is the index of the element just below - note it can be -1 if the first element in the array is
-    // greater than the key
-    return start - 1;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avm_tree.js","sourceRoot":"","sources":["../../src/avm/avm_tree.ts"],"names":[],"mappings":"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"}