@aztec/foundation 0.0.0-test.1 → 0.0.1-commit.b655e406

package/dest/trees/unbalanced_merkle_tree.js

@@ -1,63 +1,62 @@
-import { padArrayEnd } from '../collection/array.js';
 import { sha256Trunc } from '../crypto/sha256/index.js';
+import { MerkleTreeCalculator } from './merkle_tree_calculator.js';
 /**
- * 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 = sha256Trunc) {
+    if (!leaves.length) {
+        throw new Error('Cannot compute a Merkle root with no leaves');
     }
-    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]
-            ]));
-        }
-        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);
+    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 = MerkleTreeCalculator.computeTreeRootSync(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 = hasher(Buffer.concat([
+                    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 +69,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,48 @@
+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>, 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 hasher;
+    private store;
+    private leafLocations;
+    constructor(leaves: Buffer[], valueToCompress: Buffer, hasher: Hasher['hash']);
+    static create(leaves: Buffer[], valueToCompress?: Buffer<ArrayBuffer>, hasher?: (left: Buffer, right: Buffer) => 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 shiftChildrenUp;
+}
+//# sourceMappingURL=unbalanced_merkle_tree_calculator.d.ts.map

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,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,MAAM;IANzB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,aAAa,CAA0B;gBAG5B,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;IAUzC,MAAM,CAAC,MAAM,CACX,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,sBAAkB,EACjC,MAAM,IAAI,MAAM,MAAM,EAAE,OAAO,MAAM,KAAkD,MAAM,CAAC,WAAW,CAAC;IAK5G;;;OAGG;IACI,OAAO,IAAI,MAAM;IAIxB;;;;;OAKG;IACI,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAStE;;;;OAIG;IACI,yBAAyB,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAqB9E,eAAe,CAAC,SAAS,EAAE,MAAM;IAIxC;;;OAGG;IACH,OAAO,CAAC,SAAS;IAkDjB,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,eAAe;CAoBxB"}

package/dest/trees/unbalanced_merkle_tree_calculator.js

@@ -0,0 +1,162 @@
+import { sha256Trunc } from '../crypto/index.js';
+import { SiblingPath } from './sibling_path.js';
+import { UnbalancedTreeStore } from './unbalanced_tree_store.js';
+export function computeCompressedUnbalancedMerkleTreeRoot(leaves, valueToCompress = Buffer.alloc(32), hasher) {
+    const calculator = UnbalancedMerkleTreeCalculator.create(leaves, valueToCompress, 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;
+    hasher;
+    store;
+    leafLocations;
+    constructor(leaves, valueToCompress, hasher){
+        this.leaves = leaves;
+        this.valueToCompress = valueToCompress;
+        this.hasher = hasher;
+        this.leafLocations = [];
+        if (leaves.length === 0) {
+            throw Error('Cannot create a compressed unbalanced tree with 0 leaves.');
+        }
+        this.store = new UnbalancedTreeStore(leaves.length);
+        this.buildTree();
+    }
+    static create(leaves, valueToCompress = Buffer.alloc(0), hasher = (left, right)=>sha256Trunc(Buffer.concat([
+            left,
+            right
+        ]))) {
+        return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, 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 0 to the root.
+            this.store.setNode({
+                level: 0,
+                index: 0
+            }, {
+                value: Buffer.alloc(32)
+            });
+            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.
+                    const isLeaf = this.shiftNodeUp(location, parentLocation);
+                    if (!isLeaf) {
+                        this.shiftChildrenUp(location);
+                    }
+                } 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(fromLocation, toLocation) {
+        const node = this.store.getNode(fromLocation);
+        this.store.setNode(toLocation, node);
+        const isLeaf = node.leafIndex !== undefined;
+        if (isLeaf) {
+            // Update the location if the node is a leaf.
+            this.leafLocations[node.leafIndex] = toLocation;
+        }
+        return isLeaf;
+    }
+    shiftChildrenUp(parent) {
+        const [left, right] = this.store.getChildLocations(parent);
+        const level = parent.level;
+        const groupSize = 2 ** level;
+        const computeNewLocation = (index)=>({
+                level,
+                index: Math.floor(index / (groupSize * 2)) * groupSize + index % groupSize
+            });
+        const isLeftLeaf = this.shiftNodeUp(left, computeNewLocation(left.index));
+        const isRightLeaf = this.shiftNodeUp(right, computeNewLocation(right.index));
+        if (!isLeftLeaf) {
+            this.shiftChildrenUp(left);
+        }
+        if (!isRightLeaf) {
+            this.shiftChildrenUp(right);
+        }
+    }
+}

package/dest/trees/unbalanced_tree_store.d.ts

@@ -12,6 +12,7 @@ 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];

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;;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,GAAG,CAAC,GAAG,SAAS;IASzC,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS;IAIlD,OAAO,IAAI,CAAC,GAAG,SAAS;IAIxB,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"}

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,29 @@ 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;
+/** 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=index.d.ts.map

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,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/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/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@aztec/foundation",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.b655e406",
   "type": "module",
   "main": "./dest/index.js",
   "types": "./dest/index.d.ts",
   "exports": {
-    "./eslint": "./.eslintrc.cjs",
-    "./eslint.docs": "./.eslintrc.docs.cjs",
+    "./eslint": "./eslint.config.js",
+    "./eslint.docs": "./eslint.config.docs.js",
     "./prettier": "./.prettierrc.json",
     "./abi": "./dest/abi/index.js",
     "./async-map": "./dest/async-map/index.js",
     "./async-pool": "./dest/async-pool/index.js",
+    "./bigint": "./dest/bigint/index.js",
     "./collection": "./dest/collection/index.js",
     "./config": "./dest/config/index.js",
     "./crypto": "./dest/crypto/index.js",
     "./crypto/sync": "./dest/crypto/sync/index.js",
+    "./crypto/bls/bn254_keystore": "./dest/crypto/bls/bn254_keystore.js",
     "./decorators": "./dest/decorators/index.js",
     "./error": "./dest/error/index.js",
     "./eth-address": "./dest/eth-address/index.js",
@@ -38,8 +40,6 @@
     "./timer": "./dest/timer/index.js",
     "./transport": "./dest/transport/index.js",
     "./trees": "./dest/trees/index.js",
-    "./wasm": "./dest/wasm/index.js",
-    "./worker": "./dest/worker/index.js",
     "./bigint-buffer": "./dest/bigint-buffer/index.js",
     "./types": "./dest/types/index.js",
     "./schemas": "./dest/schemas/index.js",
@@ -48,19 +48,19 @@
     "./noir": "./dest/noir/index.js",
     "./testing": "./dest/testing/index.js",
     "./testing/files": "./dest/testing/files/index.js",
+    "./profiler": "./dest/profiler/index.js",
     "./array": "./dest/array/index.js",
     "./validation": "./dest/validation/index.js",
     "./promise": "./dest/promise/index.js",
     "./string": "./dest/string/index.js",
-    "./message": "./dest/message/index.js"
+    "./message": "./dest/message/index.js",
+    "./number": "./dest/number/index.js"
   },
   "scripts": {
     "build": "yarn clean && tsc -b",
     "build:dev": "tsc -b --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "generate": "true",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
@@ -96,74 +96,68 @@
     ],
     "testTimeout": 120000,
     "setupFilesAfterEnv": [
-      "../../foundation/src/jest/setup.mjs"
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ],
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
-    ]
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.0.0-test.1",
+    "@aztec/bb.js": "0.0.1-commit.b655e406",
     "@koa/cors": "^5.0.0",
-    "@noble/curves": "^1.2.0",
+    "@noble/curves": "=1.7.0",
+    "@noble/hashes": "^1.6.1",
+    "@scure/bip39": "^2.0.1",
     "bn.js": "^5.2.1",
-    "c-kzg": "4.0.0-alpha.1",
     "colorette": "^2.0.20",
-    "debug": "^4.3.4",
     "detect-node": "^2.1.0",
-    "elliptic": "^6.5.4",
     "hash.js": "^1.1.7",
-    "koa": "^2.14.2",
+    "koa": "^2.16.1",
     "koa-bodyparser": "^4.4.0",
     "koa-compress": "^5.1.0",
-    "koa-router": "^12.0.0",
+    "koa-router": "^13.1.1",
     "leveldown": "^6.1.1",
-    "levelup": "^5.1.1",
     "lodash.chunk": "^4.2.0",
     "lodash.clonedeepwith": "^4.5.0",
-    "memdown": "^6.1.1",
     "pako": "^2.1.0",
     "pino": "^9.5.0",
     "pino-pretty": "^13.0.0",
     "sha3": "^2.1.4",
-    "undici": "^7.3.0",
+    "undici": "^5.28.5",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
+    "@jest/globals": "^30.0.0",
     "@libp2p/interface": "1.3.1",
-    "@types/bn.js": "^5.1.3",
-    "@types/debug": "^4.1.7",
     "@types/detect-node": "^2.0.0",
-    "@types/elliptic": "^6.4.16",
-    "@types/jest": "^29.5.0",
-    "@types/koa": "^2.13.5",
+    "@types/jest": "^30.0.0",
+    "@types/koa": "^2.15.0",
     "@types/koa-bodyparser": "^4.3.10",
     "@types/koa-compress": "^4.0.3",
     "@types/koa-router": "^7.4.4",
     "@types/koa__cors": "^4.0.0",
     "@types/leveldown": "^4.0.3",
-    "@types/levelup": "^5.1.2",
     "@types/lodash.chunk": "^4.2.9",
     "@types/lodash.clonedeepwith": "^4.5.7",
-    "@types/memdown": "^3.0.1",
-    "@types/node": "^18.7.23",
+    "@types/node": "^22.15.17",
     "@types/pako": "^2.0.0",
     "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "^6.2.1",
-    "@typescript-eslint/parser": "^6.2.1",
     "comlink": "^4.4.1",
-    "eslint": "^8.21.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-jsdoc": "^40.1.0",
-    "eslint-plugin-no-only-tests": "^3.1.0",
-    "eslint-plugin-tsdoc": "^0.2.17",
-    "jest": "^29.5.0",
-    "prettier": "^2.7.1",
+    "eslint": "^9.26.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jsdoc": "^50.6.14",
+    "eslint-plugin-no-only-tests": "^3.3.0",
+    "eslint-plugin-tsdoc": "^0.4.0",
+    "globals": "^16.1.0",
+    "jest": "^30.0.0",
+    "prettier": "^3.5.3",
     "supertest": "^6.3.3",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4",
-    "viem": "2.22.8"
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.32.1",
+    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
   },
   "files": [
     "dest",
@@ -171,6 +165,6 @@
     "!*.test.*"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/array/array.ts

@@ -148,3 +148,16 @@ export function assertRightPadded<T>(arr: T[], isEmpty: (item: T) => boolean) {
     }
   }
 }
+
+/**
+ * Shuffles an array in-place using the Fisher-Yates algorith,
+ * @param arr - The array to shuffle
+ */
+export function shuffle<T>(arr: T[]): void {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = (Math.random() * (i + 1)) | 0;
+    const temp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = temp;
+  }
+}

package/src/async-pool/index.ts

@@ -29,6 +29,7 @@
 export function asyncPool<T, R>(poolLimit: number, iterable: T[], iteratorFn: (item: T, iterable: T[]) => Promise<R>) {
   let i = 0;
   const ret: Promise<R>[] = [];
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
   const executing: Set<Promise<R>> = new Set();
   const enqueue = (): Promise<any> => {
     if (i === iterable.length) {

package/src/bigint/index.ts

@@ -0,0 +1,20 @@
+/** Returns minimum value across a list of bigints. */
+export function minBigint(...values: bigint[]): bigint {
+  if (values.length === 0) {
+    throw new Error('Cannot get min of empty array');
+  }
+  return values.reduce((min, value) => (value < min ? value : min), values[0]);
+}
+
+/** Returns maximim value across a list of bigints. */
+export function maxBigint(...values: bigint[]): bigint {
+  if (values.length === 0) {
+    throw new Error('Cannot get max of empty array');
+  }
+  return values.reduce((max, value) => (value > max ? value : max), values[0]);
+}
+
+/** Sums an array of bigints */
+export function sumBigint(values: bigint[]): bigint {
+  return values.reduce((sum, value) => sum + value, 0n);
+}