@aztec/foundation 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/trees/membership_witness.js

@@ -0,0 +1,70 @@
+import { assertMemberLength } from '../array/array.js';
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../fields/fields.js';
+import { BufferReader, serializeToBuffer } from '../serialize/index.js';
+/**
+ * Contains information which can be used to prove that a leaf is a member of a Merkle tree.
+ */ export class MembershipWitness {
+    leafIndex;
+    siblingPath;
+    constructor(/**
+     * Size of the sibling path (number of fields it contains).
+     */ pathSize, /**
+     * Index of a leaf in the Merkle tree.
+     */ leafIndex, /**
+     * Sibling path of the leaf in the Merkle tree.
+     */ siblingPath){
+        this.leafIndex = leafIndex;
+        this.siblingPath = siblingPath;
+        assertMemberLength(this, 'siblingPath', pathSize);
+    }
+    toBuffer() {
+        return serializeToBuffer(toBufferBE(this.leafIndex, 32), ...this.siblingPath);
+    }
+    /**
+   * Creates a random membership witness. Used for testing purposes.
+   * @param pathSize - Number of fields in the sibling path.
+   * @returns Random membership witness.
+   */ static random(pathSize) {
+        return new MembershipWitness(pathSize, 0n, Array(pathSize).fill(0).map(()=>Fr.random()));
+    }
+    /**
+   * Creates a membership witness whose sibling path is full of zero fields.
+   * @param pathSize - Number of fields in the sibling path.
+   * @param leafIndex - Index of the leaf in the Merkle tree.
+   * @returns Membership witness with zero sibling path.
+   */ static empty(pathSize, leafIndex = 0n) {
+        const arr = Array(pathSize).fill(0).map(()=>Fr.ZERO);
+        return new MembershipWitness(pathSize, leafIndex, arr);
+    }
+    static fromBufferArray(leafIndex, siblingPath) {
+        return new MembershipWitness(siblingPath.length, leafIndex, siblingPath.map((x)=>Fr.fromBuffer(x)));
+    }
+    /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized `MembershipWitness`.
+   */ static fromBuffer(buffer, size) {
+        const reader = BufferReader.asReader(buffer);
+        const leafIndex = toBigIntBE(reader.readBytes(32));
+        const siblingPath = reader.readArray(size, Fr);
+        return new MembershipWitness(size, leafIndex, siblingPath);
+    }
+    /**
+   * Creates a deserializer object for a MembershipWitness with a given size.
+   * @param size - Expected size of the witness.
+   * @returns A deserializer object.
+   */ static deserializer(size) {
+        return {
+            fromBuffer: (buffer)=>{
+                const reader = BufferReader.asReader(buffer);
+                const leafIndex = toBigIntBE(reader.readBytes(32));
+                const siblingPath = reader.readArray(size, Fr);
+                return new MembershipWitness(size, leafIndex, siblingPath);
+            }
+        };
+    }
+    static fromSiblingPath(leafIndex, siblingPath) {
+        return new MembershipWitness(siblingPath.pathSize, leafIndex, siblingPath.toFields());
+    }
+}

package/dest/trees/merkle_tree.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/** A simple immutable Merkle tree container. Use a MerkleTreeCalculator to create a new instance from a set of leaves. */
+export declare class MerkleTree {
+    readonly height: number;
+    readonly nodes: Buffer[];
+    constructor(height: number, nodes: Buffer[]);
+    get root(): Buffer;
+    get leaves(): Buffer[];
+    /** Returns a sibling path to the given element or to the element in the given index. */
+    getSiblingPath(leafIndex: number): Buffer[];
+    getSiblingPath(leaf: Buffer): Buffer[];
+    /** Returns the leaf index for a given element. */
+    getIndex(element: Buffer): number;
+    /** Returns a nice string representation of the tree, useful for debugging purposes. */
+    drawTree(elemSize?: number): string;
+}
+//# sourceMappingURL=merkle_tree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/merkle_tree.ts"],"names":[],"mappings":";;AAAA,0HAA0H;AAC1H,qBAAa,UAAU;aACO,MAAM,EAAE,MAAM;aAAkB,KAAK,EAAE,MAAM,EAAE;gBAA/C,MAAM,EAAE,MAAM,EAAkB,KAAK,EAAE,MAAM,EAAE;IAO3E,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,MAAM,IAAI,MAAM,EAAE,CAErB;IAED,wFAAwF;IACjF,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAC3C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAwB7C,kDAAkD;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM;IAI/B,uFAAuF;IAChF,QAAQ,CAAC,QAAQ,SAAI;CAsB7B"}

package/dest/trees/merkle_tree.js

@@ -0,0 +1,58 @@
+/** A simple immutable Merkle tree container. Use a MerkleTreeCalculator to create a new instance from a set of leaves. */ export class MerkleTree {
+    height;
+    nodes;
+    constructor(height, nodes){
+        this.height = height;
+        this.nodes = nodes;
+        const expectedNodeCount = 2 ** (height + 1) - 1;
+        if (nodes.length !== expectedNodeCount) {
+            throw new Error(`Invalid node count for Merkle tree: got ${nodes.length} but expected ${expectedNodeCount}`);
+        }
+    }
+    get root() {
+        return this.nodes[this.nodes.length - 1];
+    }
+    get leaves() {
+        return this.nodes.slice(0, 2 ** this.height);
+    }
+    getSiblingPath(leafIndexOrLeaf) {
+        if (Buffer.isBuffer(leafIndexOrLeaf)) {
+            return this.getSiblingPath(this.getIndex(leafIndexOrLeaf));
+        }
+        const leafIndex = leafIndexOrLeaf;
+        if (leafIndex < 0 || leafIndex >= 2 ** this.height) {
+            throw new Error(`Invalid leaf index: got ${leafIndex} but leaves count is ${2 ** this.height}`);
+        }
+        const tree = this.nodes;
+        let rowSize = Math.ceil(tree.length / 2);
+        let rowOffset = 0;
+        let index = leafIndex;
+        const siblingPath = [];
+        while(rowSize > 1){
+            const isRight = index & 1;
+            siblingPath.push(tree[rowOffset + index + (isRight ? -1 : 1)]);
+            rowOffset += rowSize;
+            rowSize >>= 1;
+            index >>= 1;
+        }
+        return siblingPath;
+    }
+    /** Returns the leaf index for a given element. */ getIndex(element) {
+        return this.leaves.findIndex((leaf)=>leaf.equals(element));
+    }
+    /** Returns a nice string representation of the tree, useful for debugging purposes. */ drawTree(elemSize = 8) {
+        const levels = [];
+        const tree = this.nodes;
+        const maxRowSize = Math.ceil(tree.length / 2);
+        let paddingSize = 1;
+        let rowSize = maxRowSize;
+        let rowOffset = 0;
+        while(rowSize > 0){
+            levels.push(tree.slice(rowOffset, rowOffset + rowSize).map((n)=>n.toString('hex').slice(0, elemSize) + ' '.repeat((paddingSize - 1) * (elemSize + 1))));
+            rowOffset += rowSize;
+            paddingSize <<= 1;
+            rowSize >>= 1;
+        }
+        return levels.reverse().map((row)=>row.join(' ')).join('\n');
+    }
+}

package/dest/trees/merkle_tree_calculator.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { MerkleTree } from './merkle_tree.js';
+/**
+ * Merkle tree calculator.
+ */
+export declare class MerkleTreeCalculator {
+    private height;
+    private zeroHashes;
+    private hasher;
+    private constructor();
+    static create(height: number, zeroLeaf?: Buffer, hasher?: (left: Buffer, right: Buffer) => Promise<Buffer>): Promise<MerkleTreeCalculator>;
+    computeTree(leaves?: Buffer[]): Promise<MerkleTree>;
+    computeTreeRoot(leaves?: Buffer[]): Promise<Buffer>;
+}
+//# sourceMappingURL=merkle_tree_calculator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merkle_tree_calculator.d.ts","sourceRoot":"","sources":["../../src/trees/merkle_tree_calculator.ts"],"names":[],"mappings":";;AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;GAEG;AACH,qBAAa,oBAAoB;IACX,OAAO,CAAC,MAAM;IAAU,OAAO,CAAC,UAAU;IAAY,OAAO,CAAC,MAAM;IAAxF,OAAO;WAIM,MAAM,CACjB,MAAM,EAAE,MAAM,EACd,QAAQ,SAAmB,EAC3B,MAAM,UAAgB,MAAM,SAAS,MAAM,oBAAmD;IAS1F,WAAW,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IAsBvD,eAAe,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAmB9D"}

package/dest/trees/merkle_tree_calculator.js

@@ -0,0 +1,61 @@
+import { pedersenHash } from '@aztec/foundation/crypto';
+import { MerkleTree } from './merkle_tree.js';
+/**
+ * Merkle tree calculator.
+ */ export class MerkleTreeCalculator {
+    height;
+    zeroHashes;
+    hasher;
+    constructor(height, zeroHashes, hasher){
+        this.height = height;
+        this.zeroHashes = zeroHashes;
+        this.hasher = hasher;
+        this.hasher = hasher;
+    }
+    static async create(height, zeroLeaf = Buffer.alloc(32), hasher = async (left, right)=>(await pedersenHash([
+            left,
+            right
+        ])).toBuffer()) {
+        const zeroHashes = [
+            zeroLeaf
+        ];
+        for(let i = 0; i < height; i++){
+            zeroHashes.push(await hasher(zeroHashes[i], zeroHashes[i]));
+        }
+        return new MerkleTreeCalculator(height, zeroHashes, hasher);
+    }
+    async computeTree(leaves = []) {
+        if (leaves.length === 0) {
+            leaves = new Array(2 ** this.height).fill(this.zeroHashes[0]);
+        }
+        let result = leaves.slice();
+        for(let i = 0; i < this.height; ++i){
+            const numLeaves = 2 ** (this.height - i);
+            const newLeaves = [];
+            for(let j = 0; j < leaves.length / 2; ++j){
+                const l = leaves[j * 2];
+                const r = leaves[j * 2 + 1] || this.zeroHashes[i];
+                newLeaves[j] = await this.hasher(l, r);
+            }
+            result = result.concat(new Array(numLeaves - leaves.length).fill(this.zeroHashes[i]), newLeaves);
+            leaves = newLeaves;
+        }
+        return new MerkleTree(this.height, result);
+    }
+    async computeTreeRoot(leaves = []) {
+        if (leaves.length === 0) {
+            return this.zeroHashes[this.zeroHashes.length - 1];
+        }
+        leaves = leaves.slice();
+        for(let i = 0; i < this.height; ++i){
+            let j = 0;
+            for(; j < leaves.length / 2; ++j){
+                const l = leaves[j * 2];
+                const r = leaves[j * 2 + 1] || this.zeroHashes[i];
+                leaves[j] = await this.hasher(l, r);
+            }
+            leaves = leaves.slice(0, j);
+        }
+        return leaves[0];
+    }
+}

package/dest/trees/sibling_path.d.ts

@@ -0,0 +1,132 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../fields/index.js';
+import { type Tuple } from '../serialize/index.js';
+import type { Hasher } from './hasher.js';
+/**
+ * Contains functionality to compute and serialize/deserialize a sibling path.
+ * E.g. Sibling path for a leaf at index 3 in a tree of depth 3 consists of:
+ *      d0:                                            [ root ]
+ *      d1:                      [ ]                                               [*]
+ *      d2:         [*]                      [ ]                       [ ]                     [ ]
+ *      d3:   [ ]         [ ]          [*]         [ ]           [ ]         [ ]          [ ]        [ ].
+ *
+ *      And the elements would be ordered as: [ leaf_at_index_2, node_at_level_2_index_0, node_at_level_1_index_1 ].
+ */
+export declare class SiblingPath<N extends number> {
+    /** Size of the sibling path (number of fields it contains). */
+    pathSize: N;
+    private data;
+    /**
+     * Constructor.
+     * @param pathSize - The size of the sibling path.
+     * @param path - The sibling path data.
+     */
+    constructor(
+    /** Size of the sibling path (number of fields it contains). */
+    pathSize: N, 
+    /** The sibling path data. */
+    path: Buffer[]);
+    static get schema(): import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Buffer, string>, import("zod").ZodEffects<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"Buffer">;
+        data: import("zod").ZodArray<import("zod").ZodNumber, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "Buffer";
+        data: number[];
+    }, {
+        type: "Buffer";
+        data: number[];
+    }>, Buffer, {
+        type: "Buffer";
+        data: number[];
+    }>]>, SiblingPath<number>, string | {
+        type: "Buffer";
+        data: number[];
+    }>;
+    static schemaFor<N extends number>(size: N): import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Buffer, string>, import("zod").ZodEffects<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"Buffer">;
+        data: import("zod").ZodArray<import("zod").ZodNumber, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "Buffer";
+        data: number[];
+    }, {
+        type: "Buffer";
+        data: number[];
+    }>, Buffer, {
+        type: "Buffer";
+        data: number[];
+    }>]>, SiblingPath<N>, string | {
+        type: "Buffer";
+        data: number[];
+    }>, SiblingPath<N>, string | {
+        type: "Buffer";
+        data: number[];
+    }>;
+    toJSON(): Buffer;
+    /**
+     * Returns sibling path hashed up from the a element.
+     * @param size - The number of elements in a given path.
+     * @param zeroElement - Value of the zero element.
+     * @param hasher - Implementation of a hasher interface.
+     * @returns A sibling path hashed up from a zero element.
+     */
+    static ZERO<N extends number>(size: N, zeroElement: Buffer, hasher: Hasher): SiblingPath<N>;
+    static random<N extends number>(number: N): SiblingPath<N>;
+    /**
+     * Serializes this SiblingPath object to a buffer.
+     * @returns The buffer representation of this object.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Returns the path buffer underlying the sibling path.
+     * @returns The Buffer array representation of this object.
+     */
+    toBufferArray(): Buffer[];
+    /**
+     * Convert the Sibling Path object into an array of field elements.
+     * @returns The field array representation of this object.
+     */
+    toFields(): Fr[];
+    /**
+     * Convert Sibling Path object into a tuple of field elements.
+     * @returns A tuple representation of the sibling path.
+     */
+    toTuple(): Tuple<Fr, N>;
+    /**
+     * Deserializes a SiblingPath from a buffer.
+     * @param buf - A buffer containing the buffer representation of SiblingPath.
+     * @param offset - An offset to start deserializing from.
+     * @returns A SiblingPath object.
+     */
+    static fromBuffer<N extends number>(buf: Buffer, offset?: number): SiblingPath<N>;
+    /**
+     * Deserializes a SiblingPath object from a slice of a part of a buffer and returns the amount of bytes advanced.
+     * @param buf - A buffer representation of the sibling path.
+     * @param offset - An offset to start deserializing from.
+     * @returns The deserialized sibling path and the number of bytes advanced.
+     */
+    static deserialize<N extends number>(buf: Buffer, offset?: number): {
+        elem: SiblingPath<N>;
+        adv: number;
+    };
+    /**
+     * Serializes this SiblingPath object to a hex string representation.
+     * @returns A hex string representation of the sibling path.
+     */
+    toString(): string;
+    /**
+     * Deserializes a SiblingPath object from a hex string representation.
+     * @param repr - A hex string representation of the sibling path.
+     * @returns A SiblingPath object.
+     */
+    static fromString<N extends number>(repr: string): SiblingPath<N>;
+    /**
+     * Generate a subtree path from the current sibling path.
+     * @param subtreeHeight - The size of the subtree that we are getting the path for.
+     * @returns A new sibling path that is the for the requested subtree.
+     */
+    getSubtreeSiblingPath<SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(subtreeHeight: SubtreeHeight): SiblingPath<SubtreeSiblingPathHeight>;
+}
+/** Computes the expected root of a merkle tree given a leaf and its sibling path. */
+export declare function computeRootFromSiblingPath(leaf: Buffer, siblingPath: Buffer[], index: number, hasher?: (left: Buffer, right: Buffer) => Promise<Buffer>): Promise<Buffer>;
+//# sourceMappingURL=sibling_path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sibling_path.d.ts","sourceRoot":"","sources":["../../src/trees/sibling_path.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAExC,OAAO,EACL,KAAK,KAAK,EAIX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;GASG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM;IASrC,+DAA+D;IACxD,QAAQ,EAAE,CAAC;IATpB,OAAO,CAAC,IAAI,CAAmB;IAE/B;;;;OAIG;;IAED,+DAA+D;IACxD,QAAQ,EAAE,CAAC;IAClB,6BAA6B;IAC7B,IAAI,EAAE,MAAM,EAAE;IAKhB,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;OAEhB;IAED,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC;;;;;;;;;;;;;;;;;;;IAO1C,MAAM;IAIN;;;;;;OAMG;WACW,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAUlG,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC;IAKzC;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;OAGG;IACI,aAAa,IAAI,MAAM,EAAE;IAIhC;;;OAGG;IACI,QAAQ,IAAI,EAAE,EAAE;IAIvB;;;OAGG;IACI,OAAO,IAAI,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAK9B;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,WAAW,CAAC,CAAC,CAAC;IAK5E;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;;IAU5D;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;OAIG;WACW,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAIxE;;;;OAIG;IACI,qBAAqB,CAAC,aAAa,SAAS,MAAM,EAAE,wBAAwB,SAAS,MAAM,EAChG,aAAa,EAAE,aAAa,GAC3B,WAAW,CAAC,wBAAwB,CAAC;CAMzC;AAED,qFAAqF;AACrF,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EAAE,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,UAAgB,MAAM,SAAS,MAAM,oBAAmD,mBAQ/F"}

package/dest/trees/sibling_path.js

@@ -0,0 +1,144 @@
+import { makeTuple } from '../array/array.js';
+import { pedersenHash } from '../crypto/index.js';
+import { Fr } from '../fields/index.js';
+import { schemas } from '../schemas/index.js';
+import { assertLength, deserializeArrayFromVector, serializeArrayOfBufferableToVector } from '../serialize/index.js';
+import { bufferToHex, hexToBuffer } from '../string/index.js';
+/**
+ * Contains functionality to compute and serialize/deserialize a sibling path.
+ * E.g. Sibling path for a leaf at index 3 in a tree of depth 3 consists of:
+ *      d0:                                            [ root ]
+ *      d1:                      [ ]                                               [*]
+ *      d2:         [*]                      [ ]                       [ ]                     [ ]
+ *      d3:   [ ]         [ ]          [*]         [ ]           [ ]         [ ]          [ ]        [ ].
+ *
+ *      And the elements would be ordered as: [ leaf_at_index_2, node_at_level_2_index_0, node_at_level_1_index_1 ].
+ */ export class SiblingPath {
+    pathSize;
+    data;
+    /**
+   * Constructor.
+   * @param pathSize - The size of the sibling path.
+   * @param path - The sibling path data.
+   */ constructor(/** Size of the sibling path (number of fields it contains). */ pathSize, /** The sibling path data. */ path){
+        this.pathSize = pathSize;
+        this.data = assertLength(path, pathSize);
+    }
+    static get schema() {
+        return schemas.Buffer.transform((b)=>SiblingPath.fromBuffer(b));
+    }
+    static schemaFor(size) {
+        return schemas.Buffer.transform((b)=>SiblingPath.fromBuffer(b)).refine((path)=>path.pathSize === size, (path)=>({
+                message: `Expected sibling path size ${size} but got ${path.pathSize}`
+            }));
+    }
+    toJSON() {
+        return this.toBuffer();
+    }
+    /**
+   * Returns sibling path hashed up from the a element.
+   * @param size - The number of elements in a given path.
+   * @param zeroElement - Value of the zero element.
+   * @param hasher - Implementation of a hasher interface.
+   * @returns A sibling path hashed up from a zero element.
+   */ static ZERO(size, zeroElement, hasher) {
+        const bufs = [];
+        let current = zeroElement;
+        for(let i = 0; i < size; ++i){
+            bufs.push(current);
+            current = hasher.hash(current, current);
+        }
+        return new SiblingPath(size, bufs);
+    }
+    static random(number) {
+        const data = Array.from({
+            length: number
+        }, ()=>Fr.random().toBuffer());
+        return new SiblingPath(number, data);
+    }
+    /**
+   * Serializes this SiblingPath object to a buffer.
+   * @returns The buffer representation of this object.
+   */ toBuffer() {
+        return serializeArrayOfBufferableToVector(this.data);
+    }
+    /**
+   * Returns the path buffer underlying the sibling path.
+   * @returns The Buffer array representation of this object.
+   */ toBufferArray() {
+        return this.data;
+    }
+    /**
+   * Convert the Sibling Path object into an array of field elements.
+   * @returns The field array representation of this object.
+   */ toFields() {
+        return this.data.map((buf)=>Fr.fromBuffer(buf));
+    }
+    /**
+   * Convert Sibling Path object into a tuple of field elements.
+   * @returns A tuple representation of the sibling path.
+   */ toTuple() {
+        const array = this.toFields();
+        return makeTuple(array.length, (i)=>array[i], 0);
+    }
+    /**
+   * Deserializes a SiblingPath from a buffer.
+   * @param buf - A buffer containing the buffer representation of SiblingPath.
+   * @param offset - An offset to start deserializing from.
+   * @returns A SiblingPath object.
+   */ static fromBuffer(buf, offset = 0) {
+        const { elem } = SiblingPath.deserialize(buf, offset);
+        return elem;
+    }
+    /**
+   * Deserializes a SiblingPath object from a slice of a part of a buffer and returns the amount of bytes advanced.
+   * @param buf - A buffer representation of the sibling path.
+   * @param offset - An offset to start deserializing from.
+   * @returns The deserialized sibling path and the number of bytes advanced.
+   */ static deserialize(buf, offset = 0) {
+        const deserializePath = (buf, offset)=>({
+                elem: buf.slice(offset, offset + 32),
+                adv: 32
+            });
+        const { elem, adv } = deserializeArrayFromVector(deserializePath, buf, offset);
+        const size = elem.length;
+        return {
+            elem: new SiblingPath(size, elem),
+            adv
+        };
+    }
+    /**
+   * Serializes this SiblingPath object to a hex string representation.
+   * @returns A hex string representation of the sibling path.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Deserializes a SiblingPath object from a hex string representation.
+   * @param repr - A hex string representation of the sibling path.
+   * @returns A SiblingPath object.
+   */ static fromString(repr) {
+        return SiblingPath.fromBuffer(hexToBuffer(repr));
+    }
+    /**
+   * Generate a subtree path from the current sibling path.
+   * @param subtreeHeight - The size of the subtree that we are getting the path for.
+   * @returns A new sibling path that is the for the requested subtree.
+   */ getSubtreeSiblingPath(subtreeHeight) {
+        // Drop the size of the subtree from the path, and return the rest.
+        const subtreeData = this.data.slice(subtreeHeight);
+        const subtreePathSize = this.pathSize - subtreeHeight;
+        return new SiblingPath(subtreePathSize, subtreeData);
+    }
+}
+/** Computes the expected root of a merkle tree given a leaf and its sibling path. */ export async function computeRootFromSiblingPath(leaf, siblingPath, index, hasher = async (left, right)=>(await pedersenHash([
+        left,
+        right
+    ])).toBuffer()) {
+    let result = leaf;
+    for (const sibling of siblingPath){
+        result = index & 1 ? await hasher(sibling, result) : await hasher(result, sibling);
+        index >>= 1;
+    }
+    return result;
+}

package/dest/trees/unbalanced_merkle_tree.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { sha256Trunc } from '@aztec/foundation/crypto';
+import { sha256Trunc } from '../crypto/sha256/index.js';
 /**
  * Computes the merkle root for an unbalanced tree.
  *

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":";;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,qBAAc,GAAG,MAAM,CAwC9G;AAgDD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;EAGzE"}
+{"version":3,"file":"unbalanced_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,qBAAc,GAAG,MAAM,CAwC9G;AAgDD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;EAGzE"}

package/dest/trees/unbalanced_merkle_tree.js

@@ -1,5 +1,5 @@
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256Trunc } from '@aztec/foundation/crypto';
+import { padArrayEnd } from '../collection/array.js';
+import { sha256Trunc } from '../crypto/sha256/index.js';
 /**
  * Computes the merkle root for an unbalanced tree.
  *
@@ -7,26 +7,33 @@ import { sha256Trunc } from '@aztec/foundation/crypto';
  * 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) {
+ */ 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 {
+        } else {
             leaves = padArrayEnd(leaves, emptyLeaf, 2);
         }
     }
     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)];
+    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) {
+    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]]));
+            nextLayer[j / 2] = hasher(Buffer.concat([
+                thisLayer[j],
+                thisLayer[j + 1]
+            ]));
         }
         layerWidth /= 2;
         if (layerWidth & 1) {
@@ -35,8 +42,7 @@ export function computeUnbalancedMerkleRoot(leaves, emptyLeaf, hasher = sha256Tr
                 nextLayer.push(nodeToShift);
                 layerWidth += 1;
                 nodeToShift = Buffer.alloc(0);
-            }
-            else {
+            } 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];
@@ -58,7 +64,10 @@ function getMaxUnbalancedTreeDepth(numLeaves) {
 function findPosition(rootLevel, leafLevel, numLeaves, indexOffset, targetIndex) {
     if (numLeaves <= 1) {
         // Single leaf.
-        return { level: rootLevel, indexAtLevel: indexOffset };
+        return {
+            level: rootLevel,
+            indexAtLevel: indexOffset
+        };
     }
     // The largest balanced tree that can be created with the given number of leaves.
     const maxBalancedTreeDepth = getMaxBalancedTreeDepth(numLeaves);
@@ -71,14 +80,16 @@ function findPosition(rootLevel, leafLevel, numLeaves, indexOffset, targetIndex)
         //   And the balanced tree will be the left child of the root.
         //   There will be an extra level between the root of the balanced tree and the current root.
         const extraLevel = numRemainingLeaves ? 1 : 0;
-        return { level: rootLevel + maxBalancedTreeDepth + extraLevel, indexAtLevel: indexOffset + targetIndex };
-    }
-    else {
+        return {
+            level: rootLevel + maxBalancedTreeDepth + extraLevel,
+            indexAtLevel: indexOffset + targetIndex
+        };
+    } else {
         // Target is in the right branch.
         const rightBranchMaxLevel = getMaxUnbalancedTreeDepth(numRemainingLeaves);
         const shiftedUp = leafLevel - rootLevel - rightBranchMaxLevel - 1;
         const nextLeafLevel = leafLevel - shiftedUp;
-        const newIndexOffset = (indexOffset + numBalancedLeaves) >> shiftedUp;
+        const newIndexOffset = indexOffset + numBalancedLeaves >> shiftedUp;
         const shiftedTargetIndex = targetIndex - numBalancedLeaves;
         return findPosition(rootLevel + 1, nextLeafLevel, numRemainingLeaves, newIndexOffset, shiftedTargetIndex);
     }
@@ -87,4 +98,3 @@ export function findLeafLevelAndIndex(numLeaves, leafIndex) {
     const maxLevel = getMaxUnbalancedTreeDepth(numLeaves);
     return findPosition(0, maxLevel, numLeaves, 0, leafIndex);
 }
-//# sourceMappingURL=data:application/json;base64,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