@aztec/foundation 2.1.0-rc.9 → 3.0.0-devnet.2

package/dest/profiler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './profiler.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/profiler/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dest/profiler/index.js

@@ -0,0 +1 @@
+export * from './profiler.js';

package/dest/profiler/profiler.d.ts

@@ -0,0 +1,8 @@
+declare function reset(): void;
+declare function runAsync<ReturnType>(label: string, fn: () => Promise<ReturnType>): Promise<ReturnType>;
+export declare const profiler: {
+    reset: typeof reset;
+    runAsync: typeof runAsync;
+};
+export {};
+//# sourceMappingURL=profiler.d.ts.map

package/dest/profiler/profiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiler.d.ts","sourceRoot":"","sources":["../../src/profiler/profiler.ts"],"names":[],"mappings":"AA8BA,iBAAS,KAAK,IAAI,IAAI,CAErB;AAwDD,iBAAe,QAAQ,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAkCrG;AAED,eAAO,MAAM,QAAQ;;;CAAsB,CAAC"}

package/dest/profiler/profiler.js

@@ -0,0 +1,97 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
+const als = new AsyncLocalStorage();
+const roots = [];
+function reset() {
+    roots.length = 0;
+}
+// Strip out circular references (parent) and unused fields (start) for JSON serialization
+function serializeSpans(spans) {
+    return spans.map((span)=>({
+            label: span.label,
+            dur: span.dur,
+            count: span.count,
+            children: serializeSpans(span.children)
+        }));
+}
+let i = 0;
+function save() {
+    if (roots.length === 0) {
+        return;
+    }
+    // Find max single execution time across all spans (dur/count since dur is accumulated)
+    const findMaxSingleDuration = (spans)=>{
+        let max = 0;
+        for (const span of spans){
+            const singleDur = span.dur / span.count;
+            max = Math.max(max, singleDur);
+            if (span.children.length > 0) {
+                max = Math.max(max, findMaxSingleDuration(span.children));
+            }
+        }
+        return max;
+    };
+    const profileData = {
+        spans: serializeSpans(roots),
+        timestamp: new Date().toISOString(),
+        totalTime: findMaxSingleDuration(roots)
+    };
+    const profilePath = path.join(process.cwd(), `profile-${i++}.json`);
+    process.stdout.write(`Writing profile data to ${profilePath}\n`);
+    fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
+}
+// Hook into Jest to save after each test
+if (typeof afterEach === 'function') {
+    afterEach(()=>{
+        save();
+        reset();
+    });
+}
+// Also save on process exit for non-Jest environments
+process.on('exit', ()=>{
+    save();
+});
+// Wrapper for async functions to maintain context properly
+async function runAsync(label, fn) {
+    const parent = als.getStore();
+    // Check if we already have a span with this label in the current context
+    let existingSpan;
+    if (parent) {
+        existingSpan = parent.children.find((c)=>c.label === label);
+    } else {
+        existingSpan = roots.find((r)=>r.label === label);
+    }
+    let span;
+    if (existingSpan) {
+        // Reuse existing span and increment count
+        span = existingSpan;
+        span.count++;
+    } else {
+        // Create new span
+        span = {
+            label,
+            start: performance.now(),
+            dur: 0,
+            count: 1,
+            children: [],
+            parent
+        };
+        if (parent) {
+            parent.children.push(span);
+        } else {
+            roots.push(span);
+        }
+    }
+    const startTime = performance.now();
+    const result = await als.run(span, fn);
+    const elapsed = performance.now() - startTime;
+    // Add to total duration (for averaging)
+    span.dur += elapsed;
+    return result;
+}
+export const profiler = {
+    reset,
+    runAsync
+};

package/dest/testing/formatting.d.ts

@@ -0,0 +1,4 @@
+export declare function toInlineStrArray(arr: {
+    toString: () => string;
+}[]): string;
+//# sourceMappingURL=formatting.d.ts.map

package/dest/testing/formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../src/testing/formatting.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,CAAC,GAAG,EAAE;IAAE,QAAQ,EAAE,MAAM,MAAM,CAAA;CAAE,EAAE,GAAG,MAAM,CAE1E"}

package/dest/testing/formatting.js

@@ -0,0 +1,3 @@
+export function toInlineStrArray(arr) {
+    return `[${arr.map((f)=>f.toString()).join(',')}]`;
+}

package/dest/testing/index.d.ts

@@ -1,3 +1,4 @@
+export * from './formatting.js';
 export * from './snapshot_serializer.js';
 export * from './port_allocator.js';
 export * from './test_data.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}

package/dest/testing/index.js

@@ -1,3 +1,4 @@
+export * from './formatting.js';
 export * from './snapshot_serializer.js';
 export * from './port_allocator.js';
 export * from './test_data.js';

package/dest/trees/unbalanced_merkle_tree.d.ts

@@ -21,7 +21,6 @@ import { sha256Trunc } from '../crypto/sha256/index.js';
  * (depth 1), the final tree has a depth of 5.
  */
 export declare function computeUnbalancedMerkleTreeRoot(leaves: Buffer[], hasher?: typeof sha256Trunc): Buffer;
-export declare function getMaxUnbalancedTreeDepth(numLeaves: number): number;
 export declare function findLeafLevelAndIndex(numLeaves: number, leafIndex: number): {
     level: number;
     indexAtLevel: number;

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

@@ -1 +1 @@
-{"version":3,"file":"unbalanced_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,qBAAc,GAAG,MAAM,CA6B9F;AAYD,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,UAE1D;AAwCD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;WAhC9D,MAAM;kBAAgB,MAAM;EAmCvC"}
+{"version":3,"file":"unbalanced_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,qBAAc,GAAG,MAAM,CA6B9F;AAsDD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;WAhC9D,MAAM;kBAAgB,MAAM;EAmCvC"}

package/dest/trees/unbalanced_merkle_tree.js

@@ -57,7 +57,7 @@ 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.
-export function getMaxUnbalancedTreeDepth(numLeaves) {
+function getMaxUnbalancedTreeDepth(numLeaves) {
     return Math.ceil(Math.log2(numLeaves));
 }
 function findPosition(rootLevel, leafLevel, numLeaves, indexOffset, targetIndex) {

package/dest/trees/unbalanced_merkle_tree_calculator.d.ts

@@ -1,45 +1,48 @@
-import { type Bufferable } from '@aztec/foundation/serialize';
-import type { AsyncHasher } from '@aztec/foundation/trees';
-import { SiblingPath } from '@aztec/foundation/trees';
+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 maxDepth;
-    private hasher;
-    private cache;
-    private valueCache;
-    protected size: bigint;
-    root: Buffer;
-    constructor(maxDepth: number, hasher: AsyncHasher['hash']);
-    static create(height: number, hasher?: (left: Buffer, right: Buffer) => Promise<Buffer<ArrayBuffer>>): 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 at the given index.
+     * 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: Bufferable): Promise<SiblingPath<N>>;
+    getSiblingPath<N extends number>(value: Buffer): SiblingPath<N>;
     /**
-     * Appends the given leaves to the tree.
-     * @param leaves - The leaves to append.
-     * @returns Empty promise.
+     * 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.
      */
-    appendLeaves(leaves: Buffer[]): Promise<void>;
+    getSiblingPathByLeafIndex<N extends number>(leafIndex: number): SiblingPath<N>;
+    getLeafLocation(leafIndex: number): TreeNodeLocation;
     /**
-     * Calculates root while adding leaves and nodes to the cache.
-     * @param leaves - The leaves to append.
-     * @returns Resulting root of the tree.
+     * Adds leaves and nodes to the store. Updates the leafLocations.
+     * @param leaves - The leaves of the tree.
      */
-    private batchInsert;
-    private storeNode;
+    private buildTree;
+    private shiftNodeUp;
+    private shiftChildrenUp;
 }
 //# sourceMappingURL=unbalanced_merkle_tree_calculator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"unbalanced_merkle_tree_calculator.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree_calculator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,6BAA6B,CAAC;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAMtD;;;;;GAKG;AACH,qBAAa,8BAA8B;IAUvC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,MAAM;IAThB,OAAO,CAAC,KAAK,CAAiC;IAE9C,OAAO,CAAC,UAAU,CAAiC;IACnD,SAAS,CAAC,IAAI,EAAE,MAAM,CAAM;IAE5B,IAAI,EAAE,MAAM,CAAoB;gBAGtB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;IAGrC,MAAM,CAAC,MAAM,CACX,MAAM,EAAE,MAAM,EACd,MAAM,IAAI,MAAM,MAAM,EAAE,OAAO,MAAM,iCAC8C;IAKrF;;;OAGG;IACI,OAAO,IAAI,MAAM;IAIxB;;;;;OAKG;IACI,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAoBnF;;;;OAIG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB1D;;;;OAIG;YACW,WAAW;IAyCzB,OAAO,CAAC,SAAS;CAKlB"}
+{"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

@@ -1,132 +1,162 @@
-import { serializeToBuffer } from '@aztec/foundation/serialize';
-import { SiblingPath } from '@aztec/foundation/trees';
 import { sha256Trunc } from '../crypto/index.js';
-const indexToKeyHash = (level, index)=>`${level}:${index}`;
+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 {
-    maxDepth;
+    leaves;
+    valueToCompress;
     hasher;
-    // This map stores index and depth -> value
-    cache;
-    // This map stores value -> index and depth, since we have variable depth
-    valueCache;
-    size;
-    root;
-    constructor(maxDepth, hasher){
-        this.maxDepth = maxDepth;
+    store;
+    leafLocations;
+    constructor(leaves, valueToCompress, hasher){
+        this.leaves = leaves;
+        this.valueToCompress = valueToCompress;
         this.hasher = hasher;
-        this.cache = {};
-        this.valueCache = {};
-        this.size = 0n;
-        this.root = Buffer.alloc(32);
+        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(height, hasher = (left, right)=>Promise.resolve(sha256Trunc(Buffer.concat([
+    static create(leaves, valueToCompress = Buffer.alloc(0), hasher = (left, right)=>sha256Trunc(Buffer.concat([
             left,
             right
-        ])))) {
-        return new UnbalancedMerkleTreeCalculator(height, hasher);
+        ]))) {
+        return new UnbalancedMerkleTreeCalculator(leaves, valueToCompress, hasher);
     }
     /**
    * Returns the root of the tree.
    * @returns The root of the tree.
    */ getRoot() {
-        return this.root;
+        return this.store.getRoot().value;
     }
     /**
-   * Returns a sibling path for the element at the given index.
+   * 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) {
-        if (this.size === 1n) {
-            return Promise.resolve(new SiblingPath(0, []));
-        }
-        const path = [];
-        const [depth, _index] = this.valueCache[serializeToBuffer(value).toString('hex')].split(':');
-        let level = parseInt(depth, 10);
-        let index = BigInt(_index);
-        while(level > 0){
-            const isRight = index & 0x01n;
-            const key = indexToKeyHash(level, isRight ? index - 1n : index + 1n);
-            const sibling = this.cache[key];
-            path.push(sibling);
-            level -= 1;
-            index >>= 1n;
+        const leafIndex = this.leaves.findIndex((leaf)=>leaf.equals(value));
+        if (leafIndex === -1) {
+            throw Error(`Leaf value ${value.toString('hex')} not found in tree.`);
         }
-        return Promise.resolve(new SiblingPath(parseInt(depth, 10), path));
+        return this.getSiblingPathByLeafIndex(leafIndex);
     }
     /**
-   * Appends the given leaves to the tree.
-   * @param leaves - The leaves to append.
-   * @returns Empty promise.
-   */ async appendLeaves(leaves) {
-        if (this.size != BigInt(0)) {
-            throw Error(`Can't re-append to an unbalanced tree. Current has ${this.size} leaves.`);
+   * 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.`);
         }
-        if (leaves.length === 0) {
-            throw Error(`Can't append 0 leaves to an unbalanced tree.`);
+        const leaf = this.leaves[leafIndex];
+        if (leaf.equals(this.valueToCompress)) {
+            throw Error(`Leaf at index ${leafIndex} has been compressed.`);
         }
-        if (leaves.length === 1) {
-            this.root = leaves[0];
-        } else {
-            this.root = await this.batchInsert(leaves);
+        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);
         }
-        this.size = BigInt(leaves.length);
-        return Promise.resolve();
+        return new SiblingPath(path.length, path);
+    }
+    getLeafLocation(leafIndex) {
+        return this.leafLocations[leafIndex];
     }
     /**
-   * Calculates root while adding leaves and nodes to the cache.
-   * @param leaves - The leaves to append.
-   * @returns Resulting root of the tree.
-   */ async batchInsert(_leaves) {
-        // If we have an even number of leaves, hash them all in pairs
-        // Otherwise, store the final leaf to be shifted up to the next odd sized level
-        let [layerWidth, nodeToShift] = _leaves.length & 1 ? [
-            _leaves.length - 1,
-            serializeToBuffer(_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).map((l)=>serializeToBuffer(l));
-        let nextLayer = [];
-        // Store the bottom level leaves
-        thisLayer.forEach((leaf, i)=>this.storeNode(leaf, this.maxDepth, BigInt(i)));
-        for(let i = 0; i < this.maxDepth; i++){
-            for(let j = 0; j < layerWidth; j += 2){
-                // Store the hash of each pair one layer up
-                nextLayer[j / 2] = await this.hasher(serializeToBuffer(thisLayer[j]), serializeToBuffer(thisLayer[j + 1]));
-                this.storeNode(nextLayer[j / 2], this.maxDepth - i - 1, BigInt(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(serializeToBuffer(nodeToShift));
-                    this.storeNode(nodeToShift, this.maxDepth - i - 1, BigInt(layerWidth * 2 >> 1));
-                    layerWidth += 1;
-                    nodeToShift = Buffer.alloc(0);
+   * 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 {
-                    // 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];
+                    // 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);
             }
-            // reset the layers
-            thisLayer = nextLayer;
-            nextLayer = [];
+            toProcess = toProcessNext;
         }
-        // return the root
-        return thisLayer[0];
     }
-    storeNode(value, depth, index) {
-        const key = indexToKeyHash(depth, index);
-        this.cache[key] = value;
-        this.valueCache[value.toString('hex')] = key;
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/foundation",
-  "version": "2.1.0-rc.9",
+  "version": "3.0.0-devnet.2",
   "type": "module",
   "main": "./dest/index.js",
   "types": "./dest/index.d.ts",
@@ -47,6 +47,7 @@
     "./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",
@@ -102,7 +103,7 @@
     "testEnvironment": "../../foundation/src/jest/env.mjs"
   },
   "dependencies": {
-    "@aztec/bb.js": "2.1.0-rc.9",
+    "@aztec/bb.js": "3.0.0-devnet.2",
     "@koa/cors": "^5.0.0",
     "@noble/curves": "=1.7.0",
     "bn.js": "^5.2.1",
@@ -153,7 +154,7 @@
     "ts-node": "^10.9.1",
     "typescript": "^5.3.3",
     "typescript-eslint": "^8.32.1",
-    "viem": "2.23.7"
+    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
   },
   "files": [
     "dest",

package/src/config/env_var.ts

@@ -26,6 +26,7 @@ export type EnvVar =
   | 'BLOB_SINK_URL'
   | 'BOT_DA_GAS_LIMIT'
   | 'BOT_FEE_PAYMENT_METHOD'
+  | 'BOT_BASE_FEE_PADDING'
   | 'BOT_FLUSH_SETUP_TRANSACTIONS'
   | 'BOT_FOLLOW_CHAIN'
   | 'BOT_L2_GAS_LIMIT'
@@ -38,7 +39,6 @@ export type EnvVar =
   | 'BOT_ACCOUNT_SALT'
   | 'BOT_PRIVATE_TRANSFERS_PER_TX'
   | 'BOT_PUBLIC_TRANSFERS_PER_TX'
-  | 'BOT_PXE_URL'
   | 'BOT_RECIPIENT_ENCRYPTION_SECRET'
   | 'BOT_TOKEN_CONTRACT'
   | 'BOT_TOKEN_SALT'
@@ -173,6 +173,7 @@ export type EnvVar =
   | 'RPC_MAX_BATCH_SIZE'
   | 'RPC_MAX_BODY_SIZE'
   | 'RPC_SIMULATE_PUBLIC_MAX_GAS_LIMIT'
+  | 'RPC_SIMULATE_PUBLIC_MAX_DEBUG_LOG_MEMORY_READS'
   | 'SENTINEL_ENABLED'
   | 'SENTINEL_HISTORY_LENGTH_IN_EPOCHS'
   | 'SENTINEL_HISTORIC_PROVEN_PERFORMANCE_LENGTH_IN_EPOCHS'

package/src/config/network_name.ts

@@ -1,4 +1,11 @@
-export type NetworkNames = 'local' | 'staging-ignition' | 'staging-public' | 'testnet' | 'ignition';
+export type NetworkNames =
+  | 'local'
+  | 'staging-ignition'
+  | 'staging-public'
+  | 'testnet'
+  | 'mainnet'
+  | 'next-net'
+  | 'devnet';
 
 export function getActiveNetworkName(name?: string): NetworkNames {
   const network = name || process.env.NETWORK;
@@ -10,8 +17,12 @@ export function getActiveNetworkName(name?: string): NetworkNames {
     return network;
   } else if (network === 'testnet' || network === 'alpha-testnet') {
     return 'testnet';
-  } else if (network === 'ignition') {
-    return 'ignition';
+  } else if (network === 'mainnet') {
+    return 'mainnet';
+  } else if (network === 'next-net') {
+    return 'next-net';
+  } else if (network === 'devnet') {
+    return 'devnet';
   }
   throw new Error(`Unknown network: ${network}`);
 }