@aztec/simulator 0.74.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/avm/avm_tree.js

@@ -4,19 +4,18 @@ import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { strict as assert } from 'assert';
 import cloneDeep from 'lodash.clonedeep';
-/****************************************************/
-/****** The AvmEphemeralForest Class ****************/
-/****************************************************/
-/**
+/****************************************************/ /****** 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
+ */ export class AvmEphemeralForest {
+    treeDb;
+    treeMap;
+    indexedUpdates;
+    indexedSortedKeys;
+    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) {
+    indexedUpdates, indexedSortedKeys){
         this.treeDb = treeDb;
         this.treeMap = treeMap;
         this.indexedUpdates = indexedUpdates;
@@ -24,7 +23,11 @@ export class AvmEphemeralForest {
     }
     static async create(treeDb) {
         const treeMap = new Map();
-        for (const treeType of [MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.PUBLIC_DATA_TREE]) {
+        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);
@@ -38,12 +41,11 @@ export class AvmEphemeralForest {
         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) {
+   * 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) {
@@ -51,7 +53,7 @@ export class AvmEphemeralForest {
             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++) {
+            for(let i = 0; i < path.length; i++){
                 const siblingIndex = index ^ 1n;
                 const node = tree.getNode(siblingIndex, tree.depth - i);
                 if (node !== undefined) {
@@ -66,14 +68,13 @@ export class AvmEphemeralForest {
         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) {
+   * 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;
@@ -84,15 +85,14 @@ export class AvmEphemeralForest {
         // Append the new leaf
         tree.appendLeaf(newLeaf);
         this.setIndexedUpdates(treeId, insertIndex, newLeafPreimage);
-        return (await tree.getSiblingPath(insertIndex));
+        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 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);
@@ -109,15 +109,19 @@ export class AvmEphemeralForest {
             updatedPreimage.value = newValue;
             tree.updateLeaf(await this.hashPreimage(updatedPreimage), lowLeafIndex);
             this.setIndexedUpdates(treeId, lowLeafIndex, updatedPreimage);
-            this._updateSortedKeys(treeId, [updatedPreimage.slot], [lowLeafIndex]);
+            this._updateSortedKeys(treeId, [
+                updatedPreimage.slot
+            ], [
+                lowLeafIndex
+            ]);
             return {
                 element: updatedPreimage,
                 lowWitness: {
                     preimage: preimage,
                     index: lowLeafIndex,
-                    siblingPath: existingPublicDataSiblingPath,
+                    siblingPath: existingPublicDataSiblingPath
                 },
-                update: true,
+                update: true
             };
         }
         // We are writing to a new slot, so our preimage is a lowNullifier
@@ -129,42 +133,49 @@ export class AvmEphemeralForest {
         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]);
+        this._updateSortedKeys(treeId, [
+            newPublicDataLeaf.slot,
+            updatedLowLeaf.slot
+        ], [
+            insertionIndex,
+            lowLeafIndex
+        ]);
         return {
             element: newPublicDataLeaf,
             lowWitness: {
                 preimage,
                 index: lowLeafIndex,
-                siblingPath,
+                siblingPath
             },
             update: false,
             leafIndex: insertionIndex,
-            insertionPath: insertionPath,
+            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]);
+        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 {
+                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) {
+   * 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);
@@ -184,24 +195,29 @@ export class AvmEphemeralForest {
         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]);
+        this._updateSortedKeys(treeId, [
+            newNullifierLeaf.nullifier,
+            updatedLowNullifier.nullifier
+        ], [
+            insertionIndex,
+            index
+        ]);
         return {
             element: newNullifierLeaf,
             lowWitness: {
                 preimage,
                 index,
-                siblingPath,
+                siblingPath
             },
             leafIndex: insertionIndex,
-            insertionPath: insertionPath,
+            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) {
+   * 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
@@ -209,9 +225,8 @@ export class AvmEphemeralForest {
         return insertionPath;
     }
     /**
-     * This is wrapper around treeId to set values in the indexedUpdates map
-     */
-    setIndexedUpdates(treeId, index, preimage) {
+   * 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();
@@ -220,10 +235,9 @@ export class AvmEphemeralForest {
         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) {
+   * 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);
@@ -231,9 +245,8 @@ export class AvmEphemeralForest {
         return preimage;
     }
     /**
-     * This is wrapper around treeId to check membership (i.e. has()) of index in the indexedUpdates map
-     */
-    hasLocalUpdates(treeId, index) {
+   * 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;
@@ -241,30 +254,28 @@ export class AvmEphemeralForest {
         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) {
+   * 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) {
+   * 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.
@@ -276,7 +287,10 @@ export class AvmEphemeralForest {
         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];
+            return [
+                leafOrLowLeafWitnessFromExternalDb,
+                /*pathAbsentInEphemeralTree=*/ true
+            ];
         }
         // Otherwise, we return the closest one. First fetch the leaf from the indexed updates.
         const minIndexedUpdate = this.getIndexedUpdate(treeId, minIndexedLeafIndex);
@@ -285,56 +299,61 @@ export class AvmEphemeralForest {
         const keyFromExternal = leafOrLowLeafWitnessFromExternalDb.preimage.getKey();
         if (keyFromExternal > keyFromIndexed) {
             // this.log.debug(`Using leaf from external DB for ${MerkleTreeId[treeId]}`);
-            return [leafOrLowLeafWitnessFromExternalDb, /*pathAbsentInEphemeralTree=*/ true];
-        }
-        else {
+            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,
+                alreadyPresent: keyFromIndexed === bigIntKey
             };
-            return [leafInfo, /*pathAbsentInEphemeralTree=*/ false];
+            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) {
+   * 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]));
+        const indexInVector = indexOrNextLowestInArray(key, keyOrderedVector.map((x)=>x[0]));
         if (indexInVector !== -1) {
             const [_, leafIndex] = keyOrderedVector[indexInVector];
             return leafIndex;
-        }
-        else {
+        } 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) {
+   * 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 };
+        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));
+   * 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) {
@@ -343,42 +362,38 @@ export class AvmEphemeralForest {
         return new AppendOnlyTreeSnapshot(root, Number(tree.leafCount));
     }
 }
-/****************************************************/
-/****** Some useful Structs and Enums **************/
-/****************************************************/
-var TreeType;
-(function (TreeType) {
+/****************************************************/ /****** Some useful Structs and Enums **************/ /****************************************************/ var TreeType = /*#__PURE__*/ function(TreeType) {
     TreeType[TreeType["LEAF"] = 0] = "LEAF";
     TreeType[TreeType["NODE"] = 1] = "NODE";
-})(TreeType || (TreeType = {}));
-var SiblingStatus;
-(function (SiblingStatus) {
+    return TreeType;
+}(TreeType || {});
+var SiblingStatus = /*#__PURE__*/ 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 *****************/
-/****************************************************/
-/**
+    return SiblingStatus;
+}(SiblingStatus || {});
+/****************************************************/ /****** Some Helpful Constructors for Trees  ********/ /****************************************************/ const Node = (left, right)=>({
+        tag: 1,
+        leftTree: left,
+        rightTree: right
+    });
+const Leaf = (value)=>({
+        tag: 0,
+        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) {
+ */ export class EphemeralAvmTree {
+    root;
+    leafCount;
+    depth;
+    zeroHashes;
+    tree;
+    frontier;
+    constructor(root, leafCount, depth, zeroHashes){
         this.root = root;
         this.leafCount = leafCount;
         this.depth = depth;
@@ -390,82 +405,78 @@ export class EphemeralAvmTree {
         let zeroHash = Fr.zero();
         // Can probably cache this elsewhere
         const zeroHashes = [];
-        for (let i = 0; i < depth; i++) {
+        for(let i = 0; i < depth; i++){
             zeroHashes.push(zeroHash);
-            zeroHash = await poseidon2Hash([zeroHash, zeroHash]);
+            zeroHash = await poseidon2Hash([
+                zeroHash,
+                zeroHash
+            ]);
         }
         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) {
+   * 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) {
+   * 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) {
+   * 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) {
+        if (status === 2) {
             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++) {
+   * 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) {
+            if (node === undefined || node.tag === 0) {
                 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
+   * 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++) {
+        for(let i = 0; i < numFrontierEntries; i++){
             if (leafCount === 0) {
                 frontierIndices.push(0);
-            }
-            else if (leafCount % 2 === 0) {
+            } else if (leafCount % 2 === 0) {
                 frontierIndices.push(leafCount - 2);
-            }
-            else {
+            } else {
                 frontierIndices.push(leafCount - 1);
             }
             leafCount >>= 1;
@@ -473,11 +484,10 @@ export class EphemeralAvmTree {
         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) {
+   * 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.
@@ -488,7 +498,7 @@ export class EphemeralAvmTree {
         // 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++) {
+        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
@@ -507,159 +517,156 @@ export class EphemeralAvmTree {
         this.frontier = frontierValues;
     }
     /**
-     * Computes the root of the tree
-     */
-    getRoot() {
+   * 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;
-            }
+   * 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 1:
+                {
+                    return poseidon2Hash([
+                        await this.hashTree(tree.leftTree, depth - 1),
+                        await this.hashTree(tree.rightTree, depth - 1)
+                    ]);
+                }
+            case 0:
+                {
+                    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) {
+   * 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) {
+        } catch (e) {
             return undefined;
         }
     }
     /**
-     * This is the recursive helper for getNode
-     */
-    _getNode(nodePath, tree) {
+   * This is the recursive helper for getNode
+   */ _getNode(nodePath, tree) {
         if (nodePath.length === 0) {
             return tree;
         }
-        switch (tree.tag) {
-            case TreeType.NODE:
+        switch(tree.tag){
+            case 1:
                 return nodePath.pop() === 0 ? this._getNode(nodePath, tree.leftTree) : this._getNode(nodePath, tree.rightTree);
-            case TreeType.LEAF:
+            case 0:
                 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) {
+   * 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));
+   * @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) {
+   * 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));
-            }
+        switch(tree.tag){
+            case 1:
+                {
+                    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 0:
+                {
+                    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) {
+   * 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 };
+            switch(tree.tag){
+                case 0:
+                    return {
+                        path: acc,
+                        status: 0
+                    };
+                case 1:
+                    return {
+                        path: [],
+                        status: 2
+                    };
             }
         }
         // 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));
-            }
+        switch(tree.tag){
+            case 1:
+                {
+                    // 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 };
+            case 0:
+                return {
+                    path: [],
+                    status: 2
+                };
         }
     }
 }
 /**
  * Return the index of the key in the array, or index-1 if they key is not found.
- */
-function indexOrNextLowestInArray(key, arr) {
+ */ 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) {
+    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 {
+        } else {
             // The key + 1 is LT or EQ the arr element, so we can continue searching the bottom half
             end = mid;
         }
@@ -669,4 +676,3 @@ function indexOrNextLowestInArray(key, arr) {
     // 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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"}