@aztec/foundation 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/trees/unbalanced_merkle_tree.js

@@ -1,63 +1,85 @@
-import { padArrayEnd } from '../collection/array.js';
-import { sha256Trunc } from '../crypto/sha256/index.js';
+import { computeBalancedMerkleTreeRoot, computeBalancedMerkleTreeRootAsync, poseidonMerkleHash, shaMerkleHash } from './balanced_merkle_tree.js';
+export const computeUnbalancedShaRoot = (leaves)=>computeUnbalancedMerkleTreeRoot(leaves, shaMerkleHash);
+export const computeUnbalancedPoseidonRoot = async (leaves)=>await computeUnbalancedMerkleTreeRootAsync(leaves, poseidonMerkleHash);
 /**
- * Computes the merkle root for an unbalanced tree.
+ * Computes the Merkle root of an unbalanced tree.
  *
- * @dev Adapted from unbalanced_tree.ts.
- * Calculates the tree upwards layer by layer until we reach the root.
- * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
- * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
- */ export function computeUnbalancedMerkleRoot(leaves, emptyLeaf, hasher = sha256Trunc) {
-    // Pad leaves to 2
-    if (leaves.length < 2) {
-        if (emptyLeaf === undefined) {
-            throw new Error('Cannot compute a Merkle root with less than 2 leaves');
-        } else {
-            leaves = padArrayEnd(leaves, emptyLeaf, 2);
-        }
+ * Unlike a balanced Merkle tree, which requires the number of leaves to be a power of two, an unbalanced tree can have
+ * any number of leaves.
+ *
+ * The tree is constructed by iteratively extracting the smallest power-of-two-sized subtrees from **right to left**.
+ * For each such subtree, it computes the subtree root and then combines all subtree roots (again from right to left)
+ * into a single root using the provided hash function.
+ *
+ * Note: We need the final tree to be as shallow as possible, to minimize the size of the sibling path required to prove
+ * membership of a leaf. Therefor, the computation proceeds from right to left - smaller subtrees must always be
+ * combined before being merged with a larger sibling on their left.
+ *
+ * For example, consider an unbalanced tree made of three subtrees of sizes 2, 4, and 8. If we combine the size-2 and
+ * size-4 subtrees first (producing a subtree of depth 3), and then merge it with the size-8 subtree (also depth 3), the
+ * resulting tree has a maximum depth of 4.
+ *
+ * But if we instead combine the size-4 and size-8 subtrees first (depth 4), and then merge with the size-2 subtree
+ * (depth 1), the final tree has a depth of 5.
+ */ export function computeUnbalancedMerkleTreeRoot(leaves, hasher = shaMerkleHash, emptyRoot = Buffer.alloc(32)) {
+    if (!leaves.length) {
+        return emptyRoot;
+    }
+    if (leaves.length === 1) {
+        return leaves[0];
     }
-    const depth = Math.ceil(Math.log2(leaves.length));
-    let [layerWidth, nodeToShift] = leaves.length & 1 ? [
-        leaves.length - 1,
-        leaves[leaves.length - 1]
-    ] : [
-        leaves.length,
-        Buffer.alloc(0)
-    ];
-    // Allocate this layer's leaves and init the next layer up
-    let thisLayer = leaves.slice(0, layerWidth);
-    let nextLayer = [];
-    for(let i = 0; i < depth; i++){
-        for(let j = 0; j < layerWidth; j += 2){
-            // Store the hash of each pair one layer up
-            nextLayer[j / 2] = hasher(Buffer.concat([
-                thisLayer[j],
-                thisLayer[j + 1]
-            ]));
+    let numRemainingLeaves = leaves.length;
+    let subtreeSize = 1;
+    let root;
+    while(numRemainingLeaves > 1){
+        if ((numRemainingLeaves & subtreeSize) !== 0) {
+            const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
+            const subtreeRoot = computeBalancedMerkleTreeRoot(subtreeLeaves, hasher);
+            if (!root) {
+                root = subtreeRoot;
+            } else {
+                root = hasher(subtreeRoot, root);
+            }
+            numRemainingLeaves -= subtreeSize;
         }
-        layerWidth /= 2;
-        if (layerWidth & 1) {
-            if (nodeToShift.length) {
-                // If the next layer has odd length, and we have a node that needs to be shifted up, add it here
-                nextLayer.push(nodeToShift);
-                layerWidth += 1;
-                nodeToShift = Buffer.alloc(0);
+        subtreeSize *= 2;
+    }
+    return root;
+}
+export async function computeUnbalancedMerkleTreeRootAsync(leaves, hasher = poseidonMerkleHash, emptyRoot = Buffer.alloc(32)) {
+    if (!leaves.length) {
+        return emptyRoot;
+    }
+    if (leaves.length === 1) {
+        return leaves[0];
+    }
+    let numRemainingLeaves = leaves.length;
+    let subtreeSize = 1;
+    let root;
+    while(numRemainingLeaves > 1){
+        if ((numRemainingLeaves & subtreeSize) !== 0) {
+            const subtreeLeaves = leaves.slice(numRemainingLeaves - subtreeSize, numRemainingLeaves);
+            const subtreeRoot = await computeBalancedMerkleTreeRootAsync(subtreeLeaves, hasher);
+            if (!root) {
+                root = subtreeRoot;
             } else {
-                // If we don't have a node waiting to be shifted, store the next layer's final node to be shifted
-                layerWidth -= 1;
-                nodeToShift = nextLayer[layerWidth];
+                root = await hasher(subtreeRoot, root);
             }
+            numRemainingLeaves -= subtreeSize;
         }
-        // reset the layers
-        thisLayer = nextLayer;
-        nextLayer = [];
+        subtreeSize *= 2;
     }
-    // return the root
-    return thisLayer[0];
+    return root;
 }
-function getMaxBalancedTreeDepth(numLeaves) {
+/// Get the depth of the maximum balanced tree that can be created with the given number of leaves. The subtree will be
+/// the left most subtree of the wonky tree with a total of `numLeaves` leaves.
+///
+/// Note: All the leaves may not be used to form the tree. For example, if there are 5 leaves, the maximum depth is 2,
+/// only 4 leaves are used to form a balanced tree.
+function getMaxBalancedSubtreeDepth(numLeaves) {
     return Math.floor(Math.log2(numLeaves));
 }
+/// Get the maximum depth of an unbalanced tree that can be created with the given number of leaves.
 function getMaxUnbalancedTreeDepth(numLeaves) {
     return Math.ceil(Math.log2(numLeaves));
 }
@@ -70,7 +92,7 @@ function findPosition(rootLevel, leafLevel, numLeaves, indexOffset, targetIndex)
         };
     }
     // The largest balanced tree that can be created with the given number of leaves.
-    const maxBalancedTreeDepth = getMaxBalancedTreeDepth(numLeaves);
+    const maxBalancedTreeDepth = getMaxBalancedSubtreeDepth(numLeaves);
     const numBalancedLeaves = 2 ** maxBalancedTreeDepth;
     const numRemainingLeaves = numLeaves - numBalancedLeaves;
     if (targetIndex < numBalancedLeaves) {

package/dest/trees/unbalanced_merkle_tree_calculator.d.ts

@@ -0,0 +1,49 @@
+import type { Hasher } from './hasher.js';
+import { SiblingPath } from './sibling_path.js';
+import { type TreeNodeLocation } from './unbalanced_tree_store.js';
+export declare function computeCompressedUnbalancedMerkleTreeRoot(leaves: Buffer[], valueToCompress?: Buffer<ArrayBuffer>, emptyRoot?: Buffer<ArrayBuffer>, hasher?: Hasher['hash']): Buffer;
+/**
+ * An ephemeral unbalanced Merkle tree implementation.
+ * Follows the rollup implementation which greedily hashes pairs of nodes up the tree.
+ * Remaining rightmost nodes are shifted up until they can be paired.
+ * The values that match the `valueToCompress` are skipped and the sibling of the compressed leaf are shifted up until
+ * they can be paired.
+ * If there is only one leaf, the root is the leaf.
+ */
+export declare class UnbalancedMerkleTreeCalculator {
+    private readonly leaves;
+    private readonly valueToCompress;
+    private readonly emptyRoot;
+    private readonly hasher;
+    private store;
+    private leafLocations;
+    constructor(leaves: Buffer[], valueToCompress: Buffer, emptyRoot: Buffer, hasher: Hasher['hash']);
+    static create(leaves: Buffer[], valueToCompress?: Buffer<ArrayBuffer>, emptyRoot?: Buffer<ArrayBuffer>, hasher?: (lhs: Uint8Array<ArrayBufferLike>, rhs: Uint8Array<ArrayBufferLike>) => Buffer<ArrayBuffer>): UnbalancedMerkleTreeCalculator;
+    /**
+     * Returns the root of the tree.
+     * @returns The root of the tree.
+     */
+    getRoot(): Buffer;
+    /**
+     * Returns a sibling path for the element.
+     * @param value - The value of the element.
+     * @returns A sibling path for the element.
+     * Note: The sibling path is an array of sibling hashes, with the lowest hash (leaf hash) first, and the highest hash last.
+     */
+    getSiblingPath<N extends number>(value: Buffer): SiblingPath<N>;
+    /**
+     * Returns a sibling path for the leaf at the given index.
+     * @param leafIndex - The index of the leaf.
+     * @returns A sibling path for the leaf.
+     */
+    getSiblingPathByLeafIndex<N extends number>(leafIndex: number): SiblingPath<N>;
+    getLeafLocation(leafIndex: number): TreeNodeLocation;
+    /**
+     * Adds leaves and nodes to the store. Updates the leafLocations.
+     * @param leaves - The leaves of the tree.
+     */
+    private buildTree;
+    private shiftNodeUp;
+    private collectNodesToShift;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5iYWxhbmNlZF9tZXJrbGVfdHJlZV9jYWxjdWxhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvdW5iYWxhbmNlZF9tZXJrbGVfdHJlZV9jYWxjdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMxQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDaEQsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQXVCLE1BQU0sNEJBQTRCLENBQUM7QUFFeEYsd0JBQWdCLHlDQUF5QyxDQUN2RCxNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQ2hCLGVBQWUsc0JBQW1CLEVBQ2xDLFNBQVMsc0JBQW1CLEVBQzVCLE1BQU0sQ0FBQyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FDdEIsTUFBTSxDQUdSO0FBT0Q7Ozs7Ozs7R0FPRztBQUNILHFCQUFhLDhCQUE4QjtJQUt2QyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFDdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlO0lBQ2hDLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFQekIsT0FBTyxDQUFDLEtBQUssQ0FBZ0M7SUFDN0MsT0FBTyxDQUFDLGFBQWEsQ0FBMEI7SUFFL0MsWUFDbUIsTUFBTSxFQUFFLE1BQU0sRUFBRSxFQUNoQixlQUFlLEVBQUUsTUFBTSxFQUN2QixTQUFTLEVBQUUsTUFBTSxFQUNqQixNQUFNLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxFQUl4QztJQUVELE1BQU0sQ0FBQyxNQUFNLENBQ1gsTUFBTSxFQUFFLE1BQU0sRUFBRSxFQUNoQixlQUFlLHNCQUFrQixFQUNqQyxTQUFTLHNCQUFtQixFQUM1QixNQUFNLDhGQUFnQixrQ0FHdkI7SUFFRDs7O09BR0c7SUFDSSxPQUFPLElBQUksTUFBTSxDQUV2QjtJQUVEOzs7OztPQUtHO0lBQ0ksY0FBYyxDQUFDLENBQUMsU0FBUyxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBT3JFO0lBRUQ7Ozs7T0FJRztJQUNJLHlCQUF5QixDQUFDLENBQUMsU0FBUyxNQUFNLEVBQUUsU0FBUyxFQUFFLE1BQU0sR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBbUJwRjtJQUVNLGVBQWUsQ0FBQyxTQUFTLEVBQUUsTUFBTSxvQkFFdkM7SUFFRDs7O09BR0c7SUFDSCxPQUFPLENBQUMsU0FBUztJQStDakIsT0FBTyxDQUFDLFdBQVc7SUFZbkIsT0FBTyxDQUFDLG1CQUFtQjtDQW1CNUIifQ==

package/dest/trees/unbalanced_merkle_tree_calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalanced_merkle_tree_calculator.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree_calculator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,4BAA4B,CAAC;AAExF,wBAAgB,yCAAyC,CACvD,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,sBAAmB,EAClC,SAAS,sBAAmB,EAC5B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,GACtB,MAAM,CAGR;AAOD;;;;;;;GAOG;AACH,qBAAa,8BAA8B;IAKvC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,aAAa,CAA0B;IAE/C,YACmB,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAIxC;IAED,MAAM,CAAC,MAAM,CACX,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,sBAAkB,EACjC,SAAS,sBAAmB,EAC5B,MAAM,8FAAgB,kCAGvB;IAED;;;OAGG;IACI,OAAO,IAAI,MAAM,CAEvB;IAED;;;;;OAKG;IACI,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAOrE;IAED;;;;OAIG;IACI,yBAAyB,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAmBpF;IAEM,eAAe,CAAC,SAAS,EAAE,MAAM,oBAEvC;IAED;;;OAGG;IACH,OAAO,CAAC,SAAS;IA+CjB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,mBAAmB;CAmB5B"}

package/dest/trees/unbalanced_merkle_tree_calculator.js

@@ -0,0 +1,158 @@
+import { shaMerkleHash } from './balanced_merkle_tree.js';
+import { SiblingPath } from './sibling_path.js';
+import { UnbalancedTreeStore } from './unbalanced_tree_store.js';
+export function computeCompressedUnbalancedMerkleTreeRoot(leaves, valueToCompress = Buffer.alloc(32), emptyRoot = Buffer.alloc(32), hasher) {
+    const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, emptyRoot, hasher);
+    return calculator.getRoot();
+}
+/**
+ * An ephemeral unbalanced Merkle tree implementation.
+ * Follows the rollup implementation which greedily hashes pairs of nodes up the tree.
+ * Remaining rightmost nodes are shifted up until they can be paired.
+ * The values that match the `valueToCompress` are skipped and the sibling of the compressed leaf are shifted up until
+ * they can be paired.
+ * If there is only one leaf, the root is the leaf.
+ */ export class UnbalancedMerkleTreeCalculator {
+    leaves;
+    valueToCompress;
+    emptyRoot;
+    hasher;
+    store;
+    leafLocations;
+    constructor(leaves, valueToCompress, emptyRoot, hasher){
+        this.leaves = leaves;
+        this.valueToCompress = valueToCompress;
+        this.emptyRoot = emptyRoot;
+        this.hasher = hasher;
+        this.leafLocations = [];
+        this.store = new UnbalancedTreeStore(leaves.length);
+        this.buildTree();
+    }
+    static create(leaves, valueToCompress = Buffer.alloc(0), emptyRoot = Buffer.alloc(32), hasher = shaMerkleHash) {
+        return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, emptyRoot, hasher);
+    }
+    /**
+   * Returns the root of the tree.
+   * @returns The root of the tree.
+   */ getRoot() {
+        return this.store.getRoot().value;
+    }
+    /**
+   * Returns a sibling path for the element.
+   * @param value - The value of the element.
+   * @returns A sibling path for the element.
+   * Note: The sibling path is an array of sibling hashes, with the lowest hash (leaf hash) first, and the highest hash last.
+   */ getSiblingPath(value) {
+        const leafIndex = this.leaves.findIndex((leaf)=>leaf.equals(value));
+        if (leafIndex === -1) {
+            throw Error(`Leaf value ${value.toString('hex')} not found in tree.`);
+        }
+        return this.getSiblingPathByLeafIndex(leafIndex);
+    }
+    /**
+   * Returns a sibling path for the leaf at the given index.
+   * @param leafIndex - The index of the leaf.
+   * @returns A sibling path for the leaf.
+   */ getSiblingPathByLeafIndex(leafIndex) {
+        if (leafIndex >= this.leaves.length) {
+            throw Error(`Leaf index ${leafIndex} out of bounds. Tree has ${this.leaves.length} leaves.`);
+        }
+        const leaf = this.leaves[leafIndex];
+        if (leaf.equals(this.valueToCompress)) {
+            throw Error(`Leaf at index ${leafIndex} has been compressed.`);
+        }
+        const path = [];
+        let location = this.leafLocations[leafIndex];
+        while(location.level > 0){
+            const sibling = this.store.getSibling(location);
+            path.push(sibling.value);
+            location = this.store.getParentLocation(location);
+        }
+        return new SiblingPath(path.length, path);
+    }
+    getLeafLocation(leafIndex) {
+        return this.leafLocations[leafIndex];
+    }
+    /**
+   * Adds leaves and nodes to the store. Updates the leafLocations.
+   * @param leaves - The leaves of the tree.
+   */ buildTree() {
+        this.leafLocations = this.leaves.map((value, i)=>this.store.setLeaf(i, {
+                value,
+                leafIndex: i
+            }));
+        // Start with the leaves that are not compressed.
+        let toProcess = this.leafLocations.filter((_, i)=>!this.leaves[i].equals(this.valueToCompress));
+        if (!toProcess.length) {
+            // All leaves are compressed. Set empty root to the root.
+            this.store.setNode({
+                level: 0,
+                index: 0
+            }, {
+                value: this.emptyRoot
+            });
+            return;
+        }
+        const level = toProcess[0].level;
+        for(let i = level; i > 0; i--){
+            const toProcessNext = [];
+            for (const location of toProcess){
+                if (location.level !== i) {
+                    toProcessNext.push(location);
+                    continue;
+                }
+                const parentLocation = this.store.getParentLocation(location);
+                if (this.store.getNode(parentLocation)) {
+                    continue;
+                }
+                const sibling = this.store.getSibling(location);
+                // If sibling is undefined, all its children are compressed.
+                const shouldShiftUp = !sibling || sibling.value.equals(this.valueToCompress);
+                if (shouldShiftUp) {
+                    // The node becomes the parent if the sibling is a compressed leaf.
+                    this.shiftNodeUp(location, parentLocation);
+                } else {
+                    // Hash the value with the (right) sibling and update the parent node.
+                    const node = this.store.getNode(location);
+                    const parentValue = this.hasher(node.value, sibling.value);
+                    this.store.setNode(parentLocation, {
+                        value: parentValue
+                    });
+                }
+                // Add the parent location to be processed next.
+                toProcessNext.push(parentLocation);
+            }
+            toProcess = toProcessNext;
+        }
+    }
+    shiftNodeUp(from, to) {
+        // Collect all nodes that need to shift.
+        const nodesToShift = this.collectNodesToShift(from, to);
+        // Move all nodes to their new locations.
+        for (const { node, newLocation } of nodesToShift){
+            this.store.setNode(newLocation, node);
+            if (node.leafIndex !== undefined) {
+                this.leafLocations[node.leafIndex] = newLocation;
+            }
+        }
+    }
+    collectNodesToShift(from, to) {
+        const node = this.store.getNode(from);
+        if (!node) {
+            return [];
+        }
+        let result = [
+            {
+                node,
+                newLocation: to
+            }
+        ];
+        // If not a leaf, collect its children.
+        if (node.leafIndex === undefined) {
+            const [leftChild, rightChild] = this.store.getChildLocations(from);
+            const [leftChildNew, rightChildNew] = this.store.getChildLocations(to);
+            result = result.concat(this.collectNodesToShift(leftChild, leftChildNew)).concat(this.collectNodesToShift(rightChild, rightChildNew));
+        }
+        return result;
+    }
+}

package/dest/trees/unbalanced_tree_store.d.ts

@@ -12,8 +12,9 @@ export declare class UnbalancedTreeStore<T> {
     getChildLocations({ level, index }: TreeNodeLocation): [TreeNodeLocation, TreeNodeLocation];
     getLeaf(leafIndex: number): T | undefined;
     getNode(location: TreeNodeLocation): T | undefined;
+    getRoot(): T | undefined;
     getParent(location: TreeNodeLocation): T | undefined;
     getSibling(location: TreeNodeLocation): T | undefined;
     getChildren(location: TreeNodeLocation): [T | undefined, T | undefined];
 }
-//# sourceMappingURL=unbalanced_tree_store.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5iYWxhbmNlZF90cmVlX3N0b3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvdW5iYWxhbmNlZF90cmVlX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0IsS0FBSyxFQUFFLE1BQU0sQ0FBQztJQUNkLEtBQUssRUFBRSxNQUFNLENBQUM7Q0FDZjtBQU9ELHFCQUFhLG1CQUFtQixDQUFDLENBQUM7O0lBSWhDLFlBQVksU0FBUyxFQUFFLE1BQU0sRUFFNUI7SUFFRCxPQUFPLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsQ0FBQyxHQUFHLGdCQUFnQixDQWVyRDtJQUVELE9BQU8sQ0FBQyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLEVBQUUsQ0FBQyxRQVNuRDtJQUVELGlCQUFpQixDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLGdCQUFnQixHQUFHLGdCQUFnQixDQU10RTtJQUVELGtCQUFrQixDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLGdCQUFnQixHQUFHLGdCQUFnQixDQU12RTtJQUVELGlCQUFpQixDQUFDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFLGdCQUFnQixHQUFHLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUMsQ0FJMUY7SUFFRCxPQUFPLENBQUMsU0FBUyxFQUFFLE1BQU0sR0FBRyxDQUFDLEdBQUcsU0FBUyxDQU94QztJQUVELE9BQU8sQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsQ0FBQyxHQUFHLFNBQVMsQ0FFakQ7SUFFRCxPQUFPLElBQUksQ0FBQyxHQUFHLFNBQVMsQ0FFdkI7SUFFRCxTQUFTLENBQUMsUUFBUSxFQUFFLGdCQUFnQixHQUFHLENBQUMsR0FBRyxTQUFTLENBR25EO0lBRUQsVUFBVSxDQUFDLFFBQVEsRUFBRSxnQkFBZ0IsR0FBRyxDQUFDLEdBQUcsU0FBUyxDQUdwRDtJQUVELFdBQVcsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEdBQUcsQ0FBQyxDQUFDLEdBQUcsU0FBUyxFQUFFLENBQUMsR0FBRyxTQUFTLENBQUMsQ0FHdEU7Q0FLRiJ9

package/dest/trees/unbalanced_tree_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unbalanced_tree_store.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_tree_store.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAOD,qBAAa,mBAAmB,CAAC,CAAC;;gBAIpB,SAAS,EAAE,MAAM;IAI7B,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB;IAiBtD,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC;IAWpD,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;IAQvE,kBAAkB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;IAQxE,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAM3F,OAAO,CAAC,SAAS,EAAE,MAAM;IASzB,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS;IAIlD,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS;IAKpD,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS;IAKrD,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC;CAQxE"}
+{"version":3,"file":"unbalanced_tree_store.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_tree_store.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAOD,qBAAa,mBAAmB,CAAC,CAAC;;IAIhC,YAAY,SAAS,EAAE,MAAM,EAE5B;IAED,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB,CAerD;IAED,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,QASnD;IAED,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB,CAMtE;IAED,kBAAkB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB,CAMvE;IAED,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAI1F;IAED,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAOxC;IAED,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS,CAEjD;IAED,OAAO,IAAI,CAAC,GAAG,SAAS,CAEvB;IAED,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS,CAGnD;IAED,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS,CAGpD;IAED,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC,CAGtE;CAKF"}

package/dest/trees/unbalanced_tree_store.js

@@ -73,6 +73,12 @@ export class UnbalancedTreeStore {
     getNode(location) {
         return this.#nodeMapping.get(this.#getKey(location))?.value;
     }
+    getRoot() {
+        return this.getNode({
+            level: 0,
+            index: 0
+        });
+    }
     getParent(location) {
         const parentLocation = this.getParentLocation(location);
         return this.getNode(parentLocation);

package/dest/types/index.d.ts

@@ -14,6 +14,31 @@ export type Writeable<T> = {
 };
 /** Removes readonly modifiers for an object. */
 export declare function unfreeze<T>(obj: T): Writeable<T>;
-/** Maybe exists, maybe not. */
-export type Maybe<T extends object> = T | unknown;
-//# sourceMappingURL=index.d.ts.map
+/** Is defined type guard */
+export declare function isDefined<T>(value: T | undefined): value is T;
+/** Resolves a record-like type. Lifted from viem. */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Type-safe Event Emitter type
+ * @example
+ * export type ArchiverEmitter = TypedEventEmitter<{
+ *  [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockSourceEvent) => void;
+ *  [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockSourceEvent) => void;
+ * }>;
+ * class Archiver extends (EventEmitter as new () => ArchiverEmitter) {
+ *  // ...
+ * }
+ */
+export interface TypedEventEmitter<TEventMap extends {
+    [key in keyof TEventMap]: (...args: any[]) => void;
+}> {
+    once<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+    on<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+    off<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+    emit<K extends keyof TEventMap>(event: K, ...args: Parameters<TEventMap[K]>): boolean;
+    removeListener<K extends keyof TEventMap>(event: K, listener: TEventMap[K]): this;
+    removeAllListeners<K extends keyof TEventMap>(event: K): this;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KAEvB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,kCAAkC;AAClC,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAE1B,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/E,6CAA6C;AAC7C,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAE9D,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEhD;AAED,+BAA+B;AAC/B,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,kCAAkC;AAClC,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/E,6CAA6C;AAC7C,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAE9D,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEhD;AAED,4BAA4B;AAC5B,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,KAAK,IAAI,CAAC,CAE7D;AAED,qDAAqD;AACrD,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,GAAG,EAAE,CAAC;AAEP;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB,CAAC,SAAS,SAAS;KAAG,GAAG,IAAI,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;CAAE;IACzG,IAAI,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACxE,EAAE,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACtE,GAAG,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACvE,IAAI,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IACtF,cAAc,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAClF,kBAAkB,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAE/D"}

package/dest/types/index.js

@@ -1,3 +1,6 @@
 /** Strips methods of a type. */ /** Removes readonly modifiers for an object. */ export function unfreeze(obj) {
     return obj;
 }
+/** Is defined type guard */ export function isDefined(value) {
+    return value !== undefined;
+}

package/dest/url/index.d.ts

@@ -6,4 +6,4 @@
  * @api public
  */
 export declare function fileURLToPath(uri: string): string;
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91cmwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJBOzs7Ozs7R0FNRztBQUVILHdCQUFnQixhQUFhLENBQUMsR0FBRyxFQUFFLE1BQU0sR0FBRyxNQUFNLENBNENqRCJ9

package/dest/url/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/url/index.ts"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AAEH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA4CjD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/url/index.ts"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AAEH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA4CjD"}

package/dest/url/index.js

@@ -1,4 +1,4 @@
-/* eslint-disable */ // Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
+// Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
 // 'Software'), to deal in the Software without restriction, including

package/dest/validation/index.d.ts

@@ -6,4 +6,4 @@ export declare function required<T>(value: T | undefined, errMsg?: string): T;
  * @param err - Error message to throw if x isn't met.
  */
 export declare function assert(x: any, err: string): asserts x;
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92YWxpZGF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHlFQUF5RTtBQUN6RSx3QkFBZ0IsUUFBUSxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxHQUFHLFNBQVMsRUFBRSxNQUFNLENBQUMsRUFBRSxNQUFNLEdBQUcsQ0FBQyxDQUtwRTtBQUVEOzs7O0dBSUc7QUFDSCx3QkFBZ0IsTUFBTSxDQUFDLENBQUMsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUlyRCJ9