@aztec/simulator 0.61.0 → 0.63.0

package/dest/avm/avm_tree.js

@@ -0,0 +1,637 @@
+import { MerkleTreeId, getTreeHeight } from '@aztec/circuit-types';
+import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/circuits.js';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import cloneDeep from 'lodash.clonedeep';
+/****************************************************/
+/****** 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 preimage and the leaf index of leaf in the ephemeral tree that contains the lowest key (i.e. nullifier value or public data tree slot)
+    indexedTreeMin, 
+    // 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) {
+        this.treeDb = treeDb;
+        this.treeMap = treeMap;
+        this.indexedTreeMin = indexedTreeMin;
+        this.indexedUpdates = indexedUpdates;
+    }
+    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);
+        }
+        return new AvmEphemeralForest(treeDb, treeMap, new Map(), new Map());
+    }
+    fork() {
+        return new AvmEphemeralForest(this.treeDb, cloneDeep(this.treeMap), cloneDeep(this.indexedTreeMin), cloneDeep(this.indexedUpdates));
+    }
+    /**
+     * 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 = 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 = 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)
+     */
+    appendIndexedTree(treeId, lowLeafIndex, lowLeafPreimage, newLeafPreimage) {
+        const tree = this.treeMap.get(treeId);
+        const newLeaf = this.hashPreimage(newLeafPreimage);
+        const insertIndex = tree.leafCount;
+        const lowLeaf = 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 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 { preimage, index, update } = await this.getLeafOrLowLeafInfo(treeId, slot);
+        const siblingPath = await this.getSiblingPath(treeId, index);
+        if (update) {
+            const updatedPreimage = cloneDeep(preimage);
+            const existingPublicDataSiblingPath = siblingPath;
+            updatedPreimage.value = newValue;
+            // It is really unintuitive that by updating, we are also appending a Zero Leaf to the tree
+            // Additionally, this leaf preimage does not seem to factor into further appends
+            const emptyLeaf = new PublicDataTreeLeafPreimage(Fr.ZERO, Fr.ZERO, Fr.ZERO, 0n);
+            const insertionIndex = tree.leafCount;
+            tree.updateLeaf(this.hashPreimage(updatedPreimage), index);
+            tree.appendLeaf(Fr.ZERO);
+            this.setIndexedUpdates(treeId, index, updatedPreimage);
+            this.setIndexedUpdates(treeId, insertionIndex, emptyLeaf);
+            const insertionPath = tree.getSiblingPath(insertionIndex);
+            // Even though we append an empty leaf into the tree as a part of update - it doesnt seem to impact future inserts...
+            this._updateMinInfo(MerkleTreeId.PUBLIC_DATA_TREE, [updatedPreimage], [index]);
+            return {
+                leafIndex: insertionIndex,
+                insertionPath,
+                newOrElementToUpdate: { update: true, element: updatedPreimage },
+                lowWitness: {
+                    preimage: preimage,
+                    index: index,
+                    update: true,
+                    siblingPath: existingPublicDataSiblingPath,
+                },
+            };
+        }
+        // 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 = this.appendIndexedTree(treeId, index, updatedLowLeaf, newPublicDataLeaf);
+        // Since we are appending, we might have a new minimum public data leaf
+        this._updateMinInfo(MerkleTreeId.PUBLIC_DATA_TREE, [newPublicDataLeaf, updatedLowLeaf], [insertionIndex, index]);
+        return {
+            leafIndex: insertionIndex,
+            insertionPath: insertionPath,
+            newOrElementToUpdate: { update: false, element: newPublicDataLeaf },
+            lowWitness: {
+                preimage,
+                index: index,
+                update: false,
+                siblingPath,
+            },
+        };
+    }
+    /**
+     * This is just a helper to compare the preimages and update the minimum public data leaf
+     * @param treeId - The tree to be queried for a sibling path.
+     * @param T - The type of the preimage (PublicData or Nullifier)
+     * @param preimages - The preimages to be compared
+     * @param indices - The indices of the preimages
+     */
+    _updateMinInfo(treeId, preimages, indices) {
+        let currentMin = this.getMinInfo(treeId);
+        if (currentMin === undefined) {
+            currentMin = { preimage: preimages[0], index: indices[0] };
+        }
+        for (let i = 0; i < preimages.length; i++) {
+            if (preimages[i].getKey() <= currentMin.preimage.getKey()) {
+                currentMin = { preimage: preimages[i], index: indices[i] };
+            }
+        }
+        this.setMinInfo(treeId, currentMin.preimage, currentMin.index);
+    }
+    /**
+     * 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 { preimage, index, update } = await this.getLeafOrLowLeafInfo(treeId, nullifier);
+        const siblingPath = await this.getSiblingPath(treeId, index);
+        if (update) {
+            throw new Error('Not allowed to 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 = this.appendIndexedTree(treeId, index, updatedLowNullifier, newNullifierLeaf);
+        // Since we are appending, we might have a new minimum nullifier leaf
+        this._updateMinInfo(MerkleTreeId.NULLIFIER_TREE, [newNullifierLeaf, updatedLowNullifier], [insertionIndex, index]);
+        return {
+            leafIndex: insertionIndex,
+            insertionPath: insertionPath,
+            newOrElementToUpdate: { update: false, element: newNullifierLeaf },
+            lowWitness: {
+                preimage,
+                index,
+                update,
+                siblingPath,
+            },
+        };
+    }
+    /**
+     * 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
+     */
+    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 = tree.getSiblingPath(tree.leafCount - 1n);
+        return insertionPath;
+    }
+    /**
+     * This is wrapper around treeId to get the correct minimum leaf preimage
+     */
+    getMinInfo(treeId) {
+        const start = this.indexedTreeMin.get(treeId);
+        if (start === undefined) {
+            return undefined;
+        }
+        const [preimage, index] = start;
+        return { preimage: preimage, index };
+    }
+    /**
+     * This is wrapper around treeId to set the correct minimum leaf preimage
+     */
+    setMinInfo(treeId, preimage, index) {
+        this.indexedTreeMin.set(treeId, [preimage, index]);
+    }
+    /**
+     * 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
+     */
+    getIndexedUpdates(treeId, index) {
+        const updates = this.indexedUpdates.get(treeId);
+        if (updates === undefined) {
+            throw new Error('No updates found');
+        }
+        const preimage = updates.get(index);
+        if (preimage === undefined) {
+            throw new Error('No updates found');
+        }
+        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);
+    }
+    /**
+     * This gets the low leaf preimage and the index of the low leaf in the indexed tree given a value (slot or nullifier value)
+     * If the value is not found in the tree, it does an external lookup to the merkleDB
+     * @param treeId - The tree we are looking up in
+     * @param key - The key for which we are look up the low leaf for.
+     * @param T - The type of the preimage (PublicData or Nullifier)
+     * @returns The low leaf preimage and the index of the low leaf in the indexed tree
+     */
+    async getLeafOrLowLeafInfo(treeId, key) {
+        // This can probably be done better, we want to say if the minInfo is undefined (because this is our first operation) we do the external lookup
+        const minPreimage = this.getMinInfo(treeId);
+        const start = minPreimage?.preimage;
+        const bigIntKey = key.toBigInt();
+        // If the first element we have is already greater than the value, we need to do an external lookup
+        if (minPreimage === undefined || (start?.getKey() ?? 0n) >= key.toBigInt()) {
+            // The low public data witness is in the previous tree
+            const { index, alreadyPresent } = (await this.treeDb.getPreviousValueIndex(treeId, bigIntKey));
+            const preimage = await this.treeDb.getLeafPreimage(treeId, index);
+            // Since we have never seen this before - we should insert it into our tree
+            const siblingPath = (await this.treeDb.getSiblingPath(treeId, index)).toFields();
+            // Is it enough to just insert the sibling path without inserting the leaf? - right now probably since we will update this low nullifier index in append
+            this.treeMap.get(treeId).insertSiblingPath(index, siblingPath);
+            const lowPublicDataPreimage = preimage;
+            return { preimage: lowPublicDataPreimage, index: index, update: alreadyPresent };
+        }
+        // We look for the low element by bouncing between our local indexedUpdates map or the external DB
+        // The conditions we are looking for are:
+        // (1) Exact Match: curr.nextKey == key (this is only valid for public data tree)
+        // (2) Sandwich Match: curr.nextKey > key and curr.key < key
+        // (3) Max Condition: curr.next_index == 0 and curr.key < key
+        // Note the min condition does not need to be handled since indexed trees are prefilled with at least the 0 element
+        let found = false;
+        let curr = minPreimage.preimage;
+        let result = undefined;
+        // Temp to avoid infinite loops - the limit is the number of leaves we may have to read
+        const LIMIT = 2n ** BigInt(getTreeHeight(treeId)) - 1n;
+        let counter = 0n;
+        let lowPublicDataIndex = minPreimage.index;
+        while (!found && counter < LIMIT) {
+            if (curr.getKey() === bigIntKey) {
+                // We found an exact match - therefore this is an update
+                found = true;
+                result = { preimage: curr, index: lowPublicDataIndex, update: true };
+            }
+            else if (curr.getKey() < bigIntKey && (curr.getNextKey() === 0n || curr.getNextKey() > bigIntKey)) {
+                // We found it via sandwich or max condition, this is a low nullifier
+                found = true;
+                result = { preimage: curr, index: lowPublicDataIndex, update: false };
+            }
+            // Update the the values for the next iteration
+            else {
+                lowPublicDataIndex = curr.getNextIndex();
+                if (this.hasLocalUpdates(treeId, lowPublicDataIndex)) {
+                    curr = this.getIndexedUpdates(treeId, lowPublicDataIndex);
+                }
+                else {
+                    const preimage = (await this.treeDb.getLeafPreimage(treeId, lowPublicDataIndex));
+                    curr = preimage;
+                }
+            }
+            counter++;
+        }
+        // We did not find it - this is unexpected
+        if (result === undefined) {
+            throw new Error('No previous value found or ran out of iterations');
+        }
+        return result;
+    }
+    /**
+     * This hashes the preimage to a field element
+     */
+    hashPreimage(preimage) {
+        // Watch for this edge-case, we are hashing the key=0 leaf to 0.
+        // This is for backward compatibility with the world state implementation
+        if (preimage.getKey() === 0n) {
+            return Fr.zero();
+        }
+        const input = preimage.toHashInputs().map(x => Fr.fromBuffer(x));
+        return poseidon2Hash(input);
+    }
+}
+/****************************************************/
+/****** 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(leafCount, depth) {
+        this.leafCount = leafCount;
+        this.depth = depth;
+        let zeroHash = Fr.zero();
+        // Can probably cache this elsewhere
+        const zeroHashes = [];
+        for (let i = 0; i < this.depth; i++) {
+            zeroHashes.push(zeroHash);
+            zeroHash = poseidon2Hash([zeroHash, zeroHash]);
+        }
+        this.tree = Leaf(zeroHash);
+        this.zeroHashes = zeroHashes;
+        this.frontier = [];
+    }
+    static async create(forkedLeafCount, depth, treeDb, merkleId) {
+        const tree = new EphemeralAvmTree(forkedLeafCount, depth);
+        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
+     */
+    getSiblingPath(index) {
+        const searchPath = this._derivePathLE(index);
+        // Handle cases where we error out
+        const { path, status } = 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;
+            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
+     */
+    hashTree(tree, depth) {
+        switch (tree.tag) {
+            case TreeType.NODE: {
+                return poseidon2Hash([this.hashTree(tree.leftTree, depth - 1), 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
+     */
+    _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
+                    ? this._getSiblingPath(searchPath, tree.leftTree, [this.hashTree(tree.rightTree, searchPath.length)].concat(acc))
+                    : this._getSiblingPath(searchPath, tree.rightTree, [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 };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avm_tree.js","sourceRoot":"","sources":["../../src/avm/avm_tree.ts"],"names":[],"mappings":"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"}