@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/trees/hasher.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Defines hasher interface used by Merkle trees.
+ */
+export interface Hasher {
+    /**
+     * Hash two arrays.
+     * @param lhs - The first array.
+     * @param rhs - The second array.
+     * @returns The new 32-byte hash.
+     */
+    hash(lhs: Uint8Array, rhs: Uint8Array): Buffer<ArrayBuffer>;
+    /**
+     * Hashes an array of buffers.
+     * @param inputs - The array of buffers to hash.
+     * @returns The resulting 32-byte hash.
+     */
+    hashInputs(inputs: Buffer[]): Buffer<ArrayBuffer>;
+}
+/**
+ * Defines an async hasher interface used by Merkle trees.
+ */
+export interface AsyncHasher {
+    /**
+     * Hash two arrays.
+     * @param lhs - The first array.
+     * @param rhs - The second array.
+     * @returns The new 32-byte hash.
+     */
+    hash(lhs: Uint8Array, rhs: Uint8Array): Promise<Buffer<ArrayBuffer>>;
+    /**
+     * Hashes an array of buffers.
+     * @param inputs - The array of buffers to hash.
+     * @returns The resulting 32-byte hash.
+     */
+    hashInputs(inputs: Buffer[]): Promise<Buffer<ArrayBuffer>>;
+}
+export declare const shaMerkleHash: Hasher['hash'];
+/** Creates a poseidon2 merkle hasher with the given domain separator. */
+export declare const makePoseidonMerkleHash: (separator: number) => (lhs: Uint8Array<ArrayBufferLike>, rhs: Uint8Array<ArrayBufferLike>) => Promise<Buffer<ArrayBuffer>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzaGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvaGFzaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOztHQUVHO0FBQ0gsTUFBTSxXQUFXLE1BQU07SUFDckI7Ozs7O09BS0c7SUFDSCxJQUFJLENBQUMsR0FBRyxFQUFFLFVBQVUsRUFBRSxHQUFHLEVBQUUsVUFBVSxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUU1RDs7OztPQUlHO0lBQ0gsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUM7Q0FDbkQ7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyxXQUFXO0lBQzFCOzs7OztPQUtHO0lBQ0gsSUFBSSxDQUFDLEdBQUcsRUFBRSxVQUFVLEVBQUUsR0FBRyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFFckU7Ozs7T0FJRztJQUNILFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO0NBQzVEO0FBRUQsZUFBTyxNQUFNLGFBQWEsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUN5QixDQUFDO0FBRW5FLHlFQUF5RTtBQUN6RSxlQUFPLE1BQU0sc0JBQXNCLDZIQUcrRCxDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"hasher.d.ts","sourceRoot":"","sources":["../../src/trees/hasher.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;IAE5D;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;CACnD;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;IAErE;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;CAC5D;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,CACyB,CAAC;AAEnE,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,6HAG+D,CAAC"}

package/dest/trees/hasher.js

@@ -0,0 +1,10 @@
+import { poseidon2HashWithSeparator } from '../crypto/poseidon/index.js';
+import { sha256Trunc } from '../crypto/sha256/index.js';
+export const shaMerkleHash = (left, right)=>sha256Trunc(Buffer.concat([
+        left,
+        right
+    ]));
+/** Creates a poseidon2 merkle hasher with the given domain separator. */ export const makePoseidonMerkleHash = (separator)=>async (left, right)=>(await poseidon2HashWithSeparator([
+            left,
+            right
+        ], separator)).toBuffer();

package/dest/trees/index.d.ts

@@ -0,0 +1,13 @@
+export * from './balanced_merkle_tree_root.js';
+export * from './merkle_tree_calculator.js';
+export * from './merkle_tree.js';
+export * from './indexed_merkle_tree_calculator.js';
+export * from './indexed_merkle_tree.js';
+export * from './sibling_path.js';
+export * from './membership_witness.js';
+export * from './hasher.js';
+export * from './indexed_tree_leaf.js';
+export * from './unbalanced_merkle_tree_calculator.js';
+export * from './unbalanced_merkle_tree_root.js';
+export * from './unbalanced_tree_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90cmVlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsNEJBQTRCLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trees/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,wCAAwC,CAAC;AACvD,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC"}

package/dest/trees/index.js

@@ -0,0 +1,12 @@
+export * from './balanced_merkle_tree_root.js';
+export * from './merkle_tree_calculator.js';
+export * from './merkle_tree.js';
+export * from './indexed_merkle_tree_calculator.js';
+export * from './indexed_merkle_tree.js';
+export * from './sibling_path.js';
+export * from './membership_witness.js';
+export * from './hasher.js';
+export * from './indexed_tree_leaf.js';
+export * from './unbalanced_merkle_tree_calculator.js';
+export * from './unbalanced_merkle_tree_root.js';
+export * from './unbalanced_tree_store.js';

package/dest/trees/indexed_merkle_tree.d.ts

@@ -0,0 +1,11 @@
+import type { IndexedTreeLeafPreimage } from './indexed_tree_leaf.js';
+import { MembershipWitness } from './membership_witness.js';
+import { MerkleTree } from './merkle_tree.js';
+/** A simple immutable indexed merkle tree container. Use a IndexedMerkleTreeCalculator to create a new instance from a set of leaves. */
+export declare class IndexedMerkleTree<T extends IndexedTreeLeafPreimage, N extends number> extends MerkleTree {
+    readonly leafPreimages: T[];
+    constructor(height: N, nodes: Buffer[], leafPreimages: T[]);
+    getLowLeaf(value: bigint): T;
+    getMembershipWitness(leafIndexOrLeaf: number | Buffer): MembershipWitness<N>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXhlZF9tZXJrbGVfdHJlZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RyZWVzL2luZGV4ZWRfbWVya2xlX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN0RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFOUMseUlBQXlJO0FBQ3pJLHFCQUFhLGlCQUFpQixDQUFDLENBQUMsU0FBUyx1QkFBdUIsRUFBRSxDQUFDLFNBQVMsTUFBTSxDQUFFLFNBQVEsVUFBVTthQUlsRixhQUFhLEVBQUUsQ0FBQyxFQUFFO0lBSHBDLFlBQ0UsTUFBTSxFQUFFLENBQUMsRUFDVCxLQUFLLEVBQUUsTUFBTSxFQUFFLEVBQ0MsYUFBYSxFQUFFLENBQUMsRUFBRSxFQUduQztJQUVNLFVBQVUsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLENBQUMsQ0FZbEM7SUFFTSxvQkFBb0IsQ0FBQyxlQUFlLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FRbEY7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexed_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/indexed_merkle_tree.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,yIAAyI;AACzI,qBAAa,iBAAiB,CAAC,CAAC,SAAS,uBAAuB,EAAE,CAAC,SAAS,MAAM,CAAE,SAAQ,UAAU;aAIlF,aAAa,EAAE,CAAC,EAAE;IAHpC,YACE,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,MAAM,EAAE,EACC,aAAa,EAAE,CAAC,EAAE,EAGnC;IAEM,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAYlC;IAEM,oBAAoB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAQlF;CACF"}

package/dest/trees/indexed_merkle_tree.js

@@ -0,0 +1,27 @@
+import { Fr } from '../curves/bn254/index.js';
+import { assertLength } from '../serialize/index.js';
+import { MembershipWitness } from './membership_witness.js';
+import { MerkleTree } from './merkle_tree.js';
+/** A simple immutable indexed merkle tree container. Use a IndexedMerkleTreeCalculator to create a new instance from a set of leaves. */ export class IndexedMerkleTree extends MerkleTree {
+    leafPreimages;
+    constructor(height, nodes, leafPreimages){
+        super(height, nodes), this.leafPreimages = leafPreimages;
+    }
+    getLowLeaf(value) {
+        let lowLeaf;
+        this.leafPreimages.forEach((leaf)=>{
+            if (leaf.getKey() < value && (leaf.getNextKey() > value || leaf.getNextKey() == BigInt(0))) {
+                lowLeaf = leaf;
+            }
+        });
+        if (!lowLeaf) {
+            throw new Error(`Couldn't find low leaf for ${value}`);
+        }
+        return lowLeaf;
+    }
+    getMembershipWitness(leafIndexOrLeaf) {
+        const index = Buffer.isBuffer(leafIndexOrLeaf) ? this.getIndex(leafIndexOrLeaf) : leafIndexOrLeaf;
+        const siblingPath = this.getSiblingPath(index);
+        return new MembershipWitness(this.height, BigInt(index), assertLength(siblingPath.map(Fr.fromBuffer), this.height));
+    }
+}

package/dest/trees/indexed_merkle_tree_calculator.d.ts

@@ -0,0 +1,21 @@
+import type { IndexedTreeLeafPreimage } from '@aztec-labs/foundation/trees';
+import type { AsyncHasher } from './hasher.js';
+import { IndexedMerkleTree } from './indexed_merkle_tree.js';
+interface LeafPreimageFactory<T extends IndexedTreeLeafPreimage> {
+    fromBuffer(buffer: Buffer): T;
+}
+/**
+ * Indexed merkle tree calculator.
+ */
+export declare class IndexedMerkleTreeCalculator<T extends IndexedTreeLeafPreimage, N extends number> {
+    private height;
+    private zeroHashes;
+    private hasher;
+    private factory;
+    private constructor();
+    static create<T extends IndexedTreeLeafPreimage, N extends number>(height: N, hasher: AsyncHasher, factory: LeafPreimageFactory<T>, zeroLeaf?: Buffer<ArrayBuffer>): Promise<IndexedMerkleTreeCalculator<T, N>>;
+    computeTree(values: Buffer[]): Promise<IndexedMerkleTree<T, N>>;
+    computeTreeRoot(leaves?: Buffer[]): Promise<Buffer>;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXhlZF9tZXJrbGVfdHJlZV9jYWxjdWxhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvaW5kZXhlZF9tZXJrbGVfdHJlZV9jYWxjdWxhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFNUUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQy9DLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTdELFVBQVUsbUJBQW1CLENBQUMsQ0FBQyxTQUFTLHVCQUF1QjtJQUM3RCxVQUFVLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxDQUFDLENBQUM7Q0FDL0I7QUFFRDs7R0FFRztBQUNILHFCQUFhLDJCQUEyQixDQUFDLENBQUMsU0FBUyx1QkFBdUIsRUFBRSxDQUFDLFNBQVMsTUFBTTtJQUV4RixPQUFPLENBQUMsTUFBTTtJQUNkLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxNQUFNO0lBQ2QsT0FBTyxDQUFDLE9BQU87SUFKakIsT0FBTyxlQUtIO0lBRUosT0FBYSxNQUFNLENBQUMsQ0FBQyxTQUFTLHVCQUF1QixFQUFFLENBQUMsU0FBUyxNQUFNLEVBQ3JFLE1BQU0sRUFBRSxDQUFDLEVBQ1QsTUFBTSxFQUFFLFdBQVcsRUFDbkIsT0FBTyxFQUFFLG1CQUFtQixDQUFDLENBQUMsQ0FBQyxFQUMvQixRQUFRLHNCQUFtQiw4Q0FPNUI7SUFFSyxXQUFXLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0F5Q3BFO0lBRUssZUFBZSxDQUFDLE1BQU0sR0FBRSxNQUFNLEVBQU8sR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLENBa0I1RDtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexed_merkle_tree_calculator.d.ts","sourceRoot":"","sources":["../../src/trees/indexed_merkle_tree_calculator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,UAAU,mBAAmB,CAAC,CAAC,SAAS,uBAAuB;IAC7D,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,2BAA2B,CAAC,CAAC,SAAS,uBAAuB,EAAE,CAAC,SAAS,MAAM;IAExF,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,OAAO;IAJjB,OAAO,eAKH;IAEJ,OAAa,MAAM,CAAC,CAAC,SAAS,uBAAuB,EAAE,CAAC,SAAS,MAAM,EACrE,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC/B,QAAQ,sBAAmB,8CAO5B;IAEK,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAyCpE;IAEK,eAAe,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB5D;CACF"}

package/dest/trees/indexed_merkle_tree_calculator.js

@@ -0,0 +1,87 @@
+import { toBigIntBE } from '@aztec-labs/foundation/bigint-buffer';
+import { numToUInt32BE } from '@aztec-labs/foundation/serialize';
+import { IndexedMerkleTree } from './indexed_merkle_tree.js';
+/**
+ * Indexed merkle tree calculator.
+ */ export class IndexedMerkleTreeCalculator {
+    height;
+    zeroHashes;
+    hasher;
+    factory;
+    constructor(height, zeroHashes, hasher, factory){
+        this.height = height;
+        this.zeroHashes = zeroHashes;
+        this.hasher = hasher;
+        this.factory = factory;
+    }
+    static async create(height, hasher, factory, zeroLeaf = Buffer.alloc(32)) {
+        const zeroHashes = [
+            zeroLeaf
+        ];
+        for(let i = 0; i < height; i++){
+            zeroHashes.push(await hasher.hash(zeroHashes[i], zeroHashes[i]));
+        }
+        return new IndexedMerkleTreeCalculator(height, zeroHashes, hasher, factory);
+    }
+    async computeTree(values) {
+        if (!values.find((v)=>toBigIntBE(v) == BigInt(0))) {
+            // If we have no zero value, add one to form the zero leaf
+            values = [
+                Buffer.alloc(32),
+                ...values
+            ];
+        }
+        const sorted = values.map((v, i)=>({
+                value: v,
+                index: i
+            })).sort((a, b)=>{
+            const aBigInt = toBigIntBE(a.value);
+            const bBigInt = toBigIntBE(b.value);
+            return aBigInt < bBigInt ? 1 : aBigInt > bBigInt ? -1 : 0;
+        });
+        const indexedLeaves = sorted.map((item, i)=>({
+                leaf: this.factory.fromBuffer(Buffer.concat([
+                    item.value,
+                    ...i == 0 ? [
+                        Buffer.alloc(32),
+                        Buffer.alloc(32)
+                    ] : [
+                        sorted[i - 1].value,
+                        numToUInt32BE(sorted[i - 1].index, 32)
+                    ]
+                ])),
+                index: item.index
+            }));
+        const resortedIndexedLeaves = indexedLeaves.sort((a, b)=>a.index - b.index).map((item)=>item.leaf);
+        let leaves = await Promise.all(resortedIndexedLeaves.map((l)=>this.hasher.hashInputs(l.toHashInputs())));
+        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.hash(l, r);
+            }
+            result = result.concat(new Array(numLeaves - leaves.length).fill(this.zeroHashes[i]), newLeaves);
+            leaves = newLeaves;
+        }
+        return new IndexedMerkleTree(this.height, result, resortedIndexedLeaves);
+    }
+    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.hash(l, r);
+            }
+            leaves = leaves.slice(0, j);
+        }
+        return leaves[0];
+    }
+}

package/dest/trees/indexed_tree_leaf.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A leaf of an indexed merkle tree.
+ */
+export interface IndexedTreeLeaf {
+    /**
+     * Returns key of the leaf. It's used for indexing.
+     */
+    getKey(): bigint;
+    /**
+     * Serializes the leaf into a buffer.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Returns true if the leaf is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Updates the leaf with the data of another leaf.
+     * @param another - The leaf to update to.
+     * @returns The updated leaf.
+     */
+    updateTo(another: IndexedTreeLeaf): IndexedTreeLeaf;
+}
+/**
+ * Preimage of a merkle tree leaf.
+ */
+export interface TreeLeafPreimage {
+    /**
+     * Returns key of the leaf corresponding to this preimage.
+     */
+    getKey(): bigint;
+    /**
+     * Returns the preimage as a leaf.
+     */
+    asLeaf(): IndexedTreeLeaf;
+    /**
+     * Serializes the preimage into a buffer.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Serializes the preimage to an array of buffers for hashing.
+     */
+    toHashInputs(): Buffer[];
+}
+/**
+ * Preimage of an indexed merkle tree leaf.
+ */
+export interface IndexedTreeLeafPreimage extends TreeLeafPreimage {
+    getNextKey(): bigint;
+    /**
+     * Returns the index of the next leaf.
+     */
+    getNextIndex(): bigint;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXhlZF90cmVlX2xlYWYuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90cmVlcy9pbmRleGVkX3RyZWVfbGVhZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sV0FBVyxlQUFlO0lBQzlCOztPQUVHO0lBQ0gsTUFBTSxJQUFJLE1BQU0sQ0FBQztJQUNqQjs7T0FFRztJQUNILFFBQVEsSUFBSSxNQUFNLENBQUM7SUFDbkI7O09BRUc7SUFDSCxPQUFPLElBQUksT0FBTyxDQUFDO0lBQ25COzs7O09BSUc7SUFDSCxRQUFRLENBQUMsT0FBTyxFQUFFLGVBQWUsR0FBRyxlQUFlLENBQUM7Q0FDckQ7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyxnQkFBZ0I7SUFDL0I7O09BRUc7SUFDSCxNQUFNLElBQUksTUFBTSxDQUFDO0lBQ2pCOztPQUVHO0lBQ0gsTUFBTSxJQUFJLGVBQWUsQ0FBQztJQUMxQjs7T0FFRztJQUNILFFBQVEsSUFBSSxNQUFNLENBQUM7SUFDbkI7O09BRUc7SUFDSCxZQUFZLElBQUksTUFBTSxFQUFFLENBQUM7Q0FDMUI7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyx1QkFBd0IsU0FBUSxnQkFBZ0I7SUFDL0QsVUFBVSxJQUFJLE1BQU0sQ0FBQztJQUNyQjs7T0FFRztJQUNILFlBQVksSUFBSSxNQUFNLENBQUM7Q0FDeEIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"indexed_tree_leaf.d.ts","sourceRoot":"","sources":["../../src/trees/indexed_tree_leaf.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,MAAM,IAAI,MAAM,CAAC;IACjB;;OAEG;IACH,MAAM,IAAI,eAAe,CAAC;IAC1B;;OAEG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,UAAU,IAAI,MAAM,CAAC;IACrB;;OAEG;IACH,YAAY,IAAI,MAAM,CAAC;CACxB"}

package/dest/trees/indexed_tree_leaf.js

@@ -0,0 +1,5 @@
+/**
+ * A leaf of an indexed merkle tree.
+ */ /**
+ * Preimage of an indexed merkle tree leaf.
+ */ export { };

package/dest/trees/membership_witness.d.ts

@@ -0,0 +1,63 @@
+import { Fr } from '../curves/bn254/field.js';
+import { BufferReader, type Tuple } from '../serialize/index.js';
+import type { SiblingPath } from './sibling_path.js';
+/**
+ * Contains information which can be used to prove that a leaf is a member of a Merkle tree.
+ */
+export declare class MembershipWitness<N extends number> {
+    /**
+     * Index of a leaf in the Merkle tree.
+     */
+    leafIndex: bigint;
+    /**
+     * Sibling path of the leaf in the Merkle tree.
+     */
+    siblingPath: Tuple<Fr, N>;
+    constructor(
+    /**
+     * Size of the sibling path (number of fields it contains).
+     */
+    pathSize: N, 
+    /**
+     * Index of a leaf in the Merkle tree.
+     */
+    leafIndex: bigint, 
+    /**
+     * Sibling path of the leaf in the Merkle tree.
+     */
+    siblingPath: Tuple<Fr, N>);
+    toBuffer(): Buffer<ArrayBufferLike>;
+    toJSON(): Buffer<ArrayBufferLike>;
+    toFields(): Fr[];
+    static schemaFor<N extends number>(size: N): import("zod").ZodPipe<import("../schemas/types.js").ZodFor<Buffer<ArrayBufferLike>>, import("zod").ZodTransform<MembershipWitness<N>, Buffer<ArrayBufferLike>>>;
+    /**
+     * Creates a random membership witness. Used for testing purposes.
+     * @param pathSize - Number of fields in the sibling path.
+     * @returns Random membership witness.
+     */
+    static random<N extends number>(pathSize: N): MembershipWitness<N>;
+    /**
+     * 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<N extends number>(pathSize: N, leafIndex?: bigint): MembershipWitness<N>;
+    static fromBufferArray<N extends number>(leafIndex: bigint, siblingPath: Tuple<Buffer, N>): MembershipWitness<N>;
+    /**
+     * 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<N extends number>(buffer: Buffer | BufferReader, size: N): MembershipWitness<N>;
+    /**
+     * Creates a deserializer object for a MembershipWitness with a given size.
+     * @param size - Expected size of the witness.
+     * @returns A deserializer object.
+     */
+    static deserializer<N extends number>(size: N): {
+        fromBuffer(buffer: Buffer | BufferReader): MembershipWitness<N>;
+    };
+    static fromSiblingPath<N extends number>(leafIndex: bigint, siblingPath: SiblingPath<N>): MembershipWitness<N>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtYmVyc2hpcF93aXRuZXNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvbWVtYmVyc2hpcF93aXRuZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUU5QyxPQUFPLEVBQUUsWUFBWSxFQUFFLEtBQUssS0FBSyxFQUFxQixNQUFNLHVCQUF1QixDQUFDO0FBQ3BGLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXJEOztHQUVHO0FBQ0gscUJBQWEsaUJBQWlCLENBQUMsQ0FBQyxTQUFTLE1BQU07SUFNM0M7O09BRUc7SUFDSSxTQUFTLEVBQUUsTUFBTTtJQUN4Qjs7T0FFRztJQUNJLFdBQVcsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQVpsQztJQUNFOztPQUVHO0lBQ0gsUUFBUSxFQUFFLENBQUM7SUFDWDs7T0FFRztJQUNJLFNBQVMsRUFBRSxNQUFNO0lBQ3hCOztPQUVHO0lBQ0ksV0FBVyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBR2pDO0lBRUQsUUFBUSw0QkFFUDtJQUVELE1BQU0sNEJBRUw7SUFFRCxRQUFRLElBQUksRUFBRSxFQUFFLENBRWY7SUFFRCxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsU0FBUyxNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUMsbUtBRXpDO0lBRUQ7Ozs7T0FJRztJQUNILE9BQWMsTUFBTSxDQUFDLENBQUMsU0FBUyxNQUFNLEVBQUUsUUFBUSxFQUFFLENBQUMsd0JBUWpEO0lBRUQ7Ozs7O09BS0c7SUFDSCxPQUFjLEtBQUssQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUFFLFFBQVEsRUFBRSxDQUFDLEVBQUUsU0FBUyxTQUFLLEdBQUcsaUJBQWlCLENBQUMsQ0FBQyxDQUFDLENBS3ZGO0lBRUQsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLEdBQUcsaUJBQWlCLENBQUMsQ0FBQyxDQUFDLENBTS9HO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQyxTQUFTLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksRUFBRSxJQUFJLEVBQUUsQ0FBQyxHQUFHLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxDQUtoRztJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUMsU0FBUyxNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUMsR0FBRztRQUFFLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQTtLQUFFLENBU2xIO0lBRUQsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsV0FBVyxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUMsR0FBRyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FFN0c7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"membership_witness.d.ts","sourceRoot":"","sources":["../../src/trees/membership_witness.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,KAAK,KAAK,EAAqB,MAAM,uBAAuB,CAAC;AACpF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;GAEG;AACH,qBAAa,iBAAiB,CAAC,CAAC,SAAS,MAAM;IAM3C;;OAEG;IACI,SAAS,EAAE,MAAM;IACxB;;OAEG;IACI,WAAW,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAZlC;IACE;;OAEG;IACH,QAAQ,EAAE,CAAC;IACX;;OAEG;IACI,SAAS,EAAE,MAAM;IACxB;;OAEG;IACI,WAAW,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAGjC;IAED,QAAQ,4BAEP;IAED,MAAM,4BAEL;IAED,QAAQ,IAAI,EAAE,EAAE,CAEf;IAED,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,mKAEzC;IAED;;;;OAIG;IACH,OAAc,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC,wBAQjD;IAED;;;;;OAKG;IACH,OAAc,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,SAAK,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAKvF;IAED,MAAM,CAAC,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAM/G;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,IAAI,EAAE,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAKhG;IAED;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG;QAAE,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAA;KAAE,CASlH;IAED,MAAM,CAAC,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAE7G;CACF"}

package/dest/trees/membership_witness.js

@@ -0,0 +1,83 @@
+import { assertMemberLength } from '../array/array.js';
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../curves/bn254/field.js';
+import { schemas } from '../schemas/schemas.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);
+    }
+    toJSON() {
+        return this.toBuffer();
+    }
+    toFields() {
+        return [
+            new Fr(this.leafIndex),
+            ...this.siblingPath
+        ];
+    }
+    static schemaFor(size) {
+        return schemas.Buffer.transform((b)=>MembershipWitness.fromBuffer(b, size));
+    }
+    /**
+   * 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,16 @@
+/** 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVya2xlX3RyZWUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90cmVlcy9tZXJrbGVfdHJlZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwSEFBMEg7QUFDMUgscUJBQWEsVUFBVTthQUVILE1BQU0sRUFBRSxNQUFNO2FBQ2QsS0FBSyxFQUFFLE1BQU0sRUFBRTtJQUZqQyxZQUNrQixNQUFNLEVBQUUsTUFBTSxFQUNkLEtBQUssRUFBRSxNQUFNLEVBQUUsRUFNaEM7SUFFRCxJQUFJLElBQUksSUFBSSxNQUFNLENBRWpCO0lBRUQsSUFBSSxNQUFNLElBQUksTUFBTSxFQUFFLENBRXJCO0lBRUQsd0ZBQXdGO0lBQ2pGLGNBQWMsQ0FBQyxTQUFTLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxDQUFDO0lBQzVDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxDQUFDO0lBd0I5QyxrREFBa0Q7SUFDM0MsUUFBUSxDQUFDLE9BQU8sRUFBRSxNQUFNLFVBRTlCO0lBRUQsdUZBQXVGO0lBQ2hGLFFBQVEsQ0FBQyxRQUFRLFNBQUksVUFxQjNCO0NBQ0YifQ==

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;aAEH,MAAM,EAAE,MAAM;aACd,KAAK,EAAE,MAAM,EAAE;IAFjC,YACkB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EAAE,EAMhC;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,MAAM,IAAI,MAAM,EAAE,CAErB;IAED,wFAAwF;IACjF,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAwB9C,kDAAkD;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,UAE9B;IAED,uFAAuF;IAChF,QAAQ,CAAC,QAAQ,SAAI,UAqB3B;CACF"}

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 @@
+import { MerkleTree } from './merkle_tree.js';
+type MerkleHashFn = (left: Buffer, right: Buffer) => Promise<Buffer<ArrayBuffer>>;
+/**
+ * Merkle tree calculator.
+ */
+export declare class MerkleTreeCalculator {
+    private height;
+    private zeroHashes;
+    private hasher;
+    private constructor();
+    static create(height: number, zeroLeaf: Buffer<ArrayBufferLike> | undefined, hasher: MerkleHashFn): Promise<MerkleTreeCalculator>;
+    computeTree(leaves?: Buffer[]): Promise<MerkleTree>;
+    computeTreeRoot(leaves?: Buffer[]): Promise<Buffer>;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVya2xlX3RyZWVfY2FsY3VsYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RyZWVzL21lcmtsZV90cmVlX2NhbGN1bGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDLEtBQUssWUFBWSxHQUFHLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxLQUFLLE9BQU8sQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztBQUVsRjs7R0FFRztBQUNILHFCQUFhLG9CQUFvQjtJQUU3QixPQUFPLENBQUMsTUFBTTtJQUNkLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxNQUFNO0lBSGhCLE9BQU8sZUFNTjtJQUVELE9BQWEsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsUUFBUSxxQ0FBMkIsRUFBRSxNQUFNLEVBQUUsWUFBWSxpQ0FNNUY7SUFFSyxXQUFXLENBQUMsTUFBTSxHQUFFLE1BQU0sRUFBTyxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FvQjVEO0lBRUssZUFBZSxDQUFDLE1BQU0sR0FBRSxNQUFNLEVBQU8sR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLENBa0I1RDtDQUNGIn0=

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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,KAAK,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;AAElF;;GAEG;AACH,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IAHhB,OAAO,eAMN;IAED,OAAa,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,qCAA2B,EAAE,MAAM,EAAE,YAAY,iCAM5F;IAEK,WAAW,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAoB5D;IAEK,eAAe,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB5D;CACF"}

package/dest/trees/merkle_tree_calculator.js

@@ -0,0 +1,57 @@
+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) {
+        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];
+    }
+}