@aztec/merkle-tree 0.1.0-alpha10

package/dest/pedersen.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" resolution-mode="require"/>
+import { IWasmModule } from '@aztec/foundation/wasm';
+import { Hasher } from './hasher.js';
+/**
+ * A helper class encapsulating Pedersen hash functionality.
+ */
+export declare class Pedersen implements Hasher {
+    private wasm;
+    constructor(wasm: IWasmModule);
+    /**
+     * Compresses two 32-byte hashes.
+     * @param lhs - The first hash.
+     * @param rhs - The second hash.
+     * @returns The new 32-byte hash.
+     */
+    compress(lhs: Uint8Array, rhs: Uint8Array): Buffer;
+    /**
+     * Compresses an array of buffers.
+     * @param inputs - The array of buffers to compress.
+     * @returns The resulting 32-byte hash.
+     */
+    compressInputs(inputs: Buffer[]): Buffer;
+    /**
+     * Get a 32-byte pedersen hash from a buffer.
+     * @param data - The data buffer.
+     * @returns The resulting hash buffer.
+     */
+    hashToField(data: Uint8Array): Buffer;
+    /**
+     * Given a buffer containing 32 byte pedersen leaves, return a new buffer containing the leaves and all pairs of
+     * nodes that define a merkle tree.
+     *
+     * E.g.
+     * Input:  [1][2][3][4]
+     * Output: [1][2][3][4][compress(1,2)][compress(3,4)][compress(5,6)].
+     *
+     * @param leaves - The 32 byte pedersen leaves.
+     * @returns A tree represented by an array.
+     */
+    hashToTree(leaves: Buffer[]): Promise<Buffer[]>;
+}
+//# sourceMappingURL=pedersen.d.ts.map

package/dest/pedersen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pedersen.d.ts","sourceRoot":"","sources":["../src/pedersen.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAOrD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;GAEG;AACH,qBAAa,QAAS,YAAW,MAAM;IACzB,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,WAAW;IAErC;;;;;OAKG;IACI,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM;IAIzD;;;;OAIG;IACI,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAI/C;;;;OAIG;IACI,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAI5C;;;;;;;;;;OAUG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAGvD"}

package/dest/pedersen.js

@@ -0,0 +1,49 @@
+import { pedersenCompress, pedersenGetHash, pedersenGetHashTree, pedersenHashInputs, } from '@aztec/circuits.js/barretenberg';
+/**
+ * A helper class encapsulating Pedersen hash functionality.
+ */
+export class Pedersen {
+    constructor(wasm) {
+        this.wasm = wasm;
+    }
+    /**
+     * Compresses two 32-byte hashes.
+     * @param lhs - The first hash.
+     * @param rhs - The second hash.
+     * @returns The new 32-byte hash.
+     */
+    compress(lhs, rhs) {
+        return pedersenCompress(this.wasm, lhs, rhs);
+    }
+    /**
+     * Compresses an array of buffers.
+     * @param inputs - The array of buffers to compress.
+     * @returns The resulting 32-byte hash.
+     */
+    compressInputs(inputs) {
+        return pedersenHashInputs(this.wasm, inputs);
+    }
+    /**
+     * Get a 32-byte pedersen hash from a buffer.
+     * @param data - The data buffer.
+     * @returns The resulting hash buffer.
+     */
+    hashToField(data) {
+        return pedersenGetHash(this.wasm, Buffer.from(data));
+    }
+    /**
+     * Given a buffer containing 32 byte pedersen leaves, return a new buffer containing the leaves and all pairs of
+     * nodes that define a merkle tree.
+     *
+     * E.g.
+     * Input:  [1][2][3][4]
+     * Output: [1][2][3][4][compress(1,2)][compress(3,4)][compress(5,6)].
+     *
+     * @param leaves - The 32 byte pedersen leaves.
+     * @returns A tree represented by an array.
+     */
+    hashToTree(leaves) {
+        return Promise.resolve(pedersenGetHashTree(this.wasm, leaves));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVkZXJzZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvcGVkZXJzZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLGdCQUFnQixFQUNoQixlQUFlLEVBQ2YsbUJBQW1CLEVBQ25CLGtCQUFrQixHQUNuQixNQUFNLGlDQUFpQyxDQUFDO0FBR3pDOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFFBQVE7SUFDbkIsWUFBb0IsSUFBaUI7UUFBakIsU0FBSSxHQUFKLElBQUksQ0FBYTtJQUFHLENBQUM7SUFFekM7Ozs7O09BS0c7SUFDSSxRQUFRLENBQUMsR0FBZSxFQUFFLEdBQWU7UUFDOUMsT0FBTyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLGNBQWMsQ0FBQyxNQUFnQjtRQUNwQyxPQUFPLGtCQUFrQixDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDL0MsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxXQUFXLENBQUMsSUFBZ0I7UUFDakMsT0FBTyxlQUFlLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDdkQsQ0FBQztJQUVEOzs7Ozs7Ozs7O09BVUc7SUFDSSxVQUFVLENBQUMsTUFBZ0I7UUFDaEMsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUNqRSxDQUFDO0NBQ0YifQ==

package/dest/sibling_path/sibling_path.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Pedersen } from '../pedersen.js';
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * 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;
+    /**
+     * 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 pedersen - Implementation of a hasher interface using the Pedersen hash.
+     * @returns A sibling path hashed up from a zero element.
+     */
+    static ZERO<N extends number>(size: N, zeroElement: Buffer, pedersen: Pedersen): SiblingPath<N>;
+    /**
+     * 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[]);
+    /**
+     * 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.
+     */
+    toFieldArray(): Fr[];
+    /**
+     * 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>;
+}
+//# sourceMappingURL=sibling_path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sibling_path.d.ts","sourceRoot":"","sources":["../../src/sibling_path/sibling_path.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C;;;;;;;;;GASG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM;IA0BrC;;OAEG;IACI,QAAQ,EAAE,CAAC;IA5BpB,OAAO,CAAC,IAAI,CAAmB;IAE/B;;;;;;OAMG;WACW,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC;IAUtG;;;;OAIG;;IAED;;OAEG;IACI,QAAQ,EAAE,CAAC;IAClB;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE;IAKhB;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;OAGG;IACI,aAAa,IAAI,MAAM,EAAE;IAIhC;;;OAGG;IACI,YAAY,IAAI,EAAE,EAAE;IAI3B;;;;;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"}

package/dest/sibling_path/sibling_path.js

@@ -0,0 +1,120 @@
+import { assertLength, deserializeArrayFromVector, serializeBufferArrayToVector, } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * 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 {
+    /**
+     * 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 pedersen - Implementation of a hasher interface using the Pedersen hash.
+     * @returns A sibling path hashed up from a zero element.
+     */
+    static ZERO(size, zeroElement, pedersen) {
+        const bufs = [];
+        let current = zeroElement;
+        for (let i = 0; i < size; ++i) {
+            bufs.push(current);
+            current = pedersen.compress(current, current);
+        }
+        return new SiblingPath(size, bufs);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Serializes this SiblingPath object to a buffer.
+     * @returns The buffer representation of this object.
+     */
+    toBuffer() {
+        return serializeBufferArrayToVector(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.
+     */
+    toFieldArray() {
+        return this.data.map(buf => Fr.fromBuffer(buf));
+    }
+    /**
+     * 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 this.toBuffer().toString('hex');
+    }
+    /**
+     * 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(Buffer.from(repr, 'hex'));
+    }
+    /**
+     * 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/sparse_tree/sparse_tree.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import { UpdateOnlyTree } from '../interfaces/update_only_tree.js';
+import { TreeBase } from '../tree_base.js';
+/**
+ * A Merkle tree implementation that uses a LevelDB database to store the tree.
+ */
+export declare class SparseTree extends TreeBase implements UpdateOnlyTree {
+    /**
+     * Updates a leaf in the tree.
+     * @param leaf - New contents of the leaf.
+     * @param index - Index of the leaf to be updated.
+     */
+    updateLeaf(leaf: Buffer, index: bigint): Promise<void>;
+}
+//# sourceMappingURL=sparse_tree.d.ts.map

package/dest/sparse_tree/sparse_tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparse_tree.d.ts","sourceRoot":"","sources":["../../src/sparse_tree/sparse_tree.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAgB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEzD;;GAEG;AACH,qBAAa,UAAW,SAAQ,QAAS,YAAW,cAAc;IAChE;;;;OAIG;IACU,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAmBpE"}

package/dest/sparse_tree/sparse_tree.js

@@ -0,0 +1,31 @@
+import { INITIAL_LEAF, TreeBase } from '../tree_base.js';
+/**
+ * A Merkle tree implementation that uses a LevelDB database to store the tree.
+ */
+export class SparseTree extends TreeBase {
+    /**
+     * Updates a leaf in the tree.
+     * @param leaf - New contents of the leaf.
+     * @param index - Index of the leaf to be updated.
+     */
+    async updateLeaf(leaf, index) {
+        if (index > this.maxIndex) {
+            throw Error(`Index out of bounds. Index ${index}, max index: ${this.maxIndex}.`);
+        }
+        const insertingZeroElement = leaf.equals(INITIAL_LEAF);
+        const originallyZeroElement = (await this.getLeafValue(index, true))?.equals(INITIAL_LEAF);
+        if (insertingZeroElement && originallyZeroElement) {
+            return;
+        }
+        await this.addLeafToCacheAndHashToRoot(leaf, index);
+        if (insertingZeroElement) {
+            // Deleting element (originally non-zero and new value is zero)
+            this.cachedSize = (this.cachedSize ?? this.size) - 1n;
+        }
+        else if (originallyZeroElement) {
+            // Inserting new element (originally zero and new value is non-zero)
+            this.cachedSize = (this.cachedSize ?? this.size) + 1n;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhcnNlX3RyZWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3BhcnNlX3RyZWUvc3BhcnNlX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUV6RDs7R0FFRztBQUNILE1BQU0sT0FBTyxVQUFXLFNBQVEsUUFBUTtJQUN0Qzs7OztPQUlHO0lBQ0ksS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFZLEVBQUUsS0FBYTtRQUNqRCxJQUFJLEtBQUssR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ3pCLE1BQU0sS0FBSyxDQUFDLDhCQUE4QixLQUFLLGdCQUFnQixJQUFJLENBQUMsUUFBUSxHQUFHLENBQUMsQ0FBQztTQUNsRjtRQUVELE1BQU0sb0JBQW9CLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN2RCxNQUFNLHFCQUFxQixHQUFHLENBQUMsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUMzRixJQUFJLG9CQUFvQixJQUFJLHFCQUFxQixFQUFFO1lBQ2pELE9BQU87U0FDUjtRQUNELE1BQU0sSUFBSSxDQUFDLDJCQUEyQixDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztRQUNwRCxJQUFJLG9CQUFvQixFQUFFO1lBQ3hCLCtEQUErRDtZQUMvRCxJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1NBQ3ZEO2FBQU0sSUFBSSxxQkFBcUIsRUFBRTtZQUNoQyxvRUFBb0U7WUFDcEUsSUFBSSxDQUFDLFVBQVUsR0FBRyxDQUFDLElBQUksQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztTQUN2RDtJQUNILENBQUM7Q0FDRiJ9

package/dest/sparse_tree/sparse_tree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sparse_tree.test.d.ts.map

package/dest/sparse_tree/sparse_tree.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparse_tree.test.d.ts","sourceRoot":"","sources":["../../src/sparse_tree/sparse_tree.test.ts"],"names":[],"mappings":""}

package/dest/sparse_tree/sparse_tree.test.js

@@ -0,0 +1,132 @@
+import { default as levelup } from 'levelup';
+import { treeTestSuite } from '../test/test_suite.js';
+import { SparseTree } from './sparse_tree.js';
+import { standardBasedTreeTestSuite } from '../test/standard_based_test_suite.js';
+import { createMemDown } from '../test/utils/create_mem_down.js';
+import { Pedersen } from '../pedersen.js';
+import { randomBytes } from 'crypto';
+import { INITIAL_LEAF, SiblingPath } from '../index.js';
+import { newTree } from '../new_tree.js';
+import { loadTree } from '../load_tree.js';
+import { createLogger } from '@aztec/foundation/log';
+import { CircuitsWasm } from '@aztec/circuits.js';
+const log = createLogger('aztec:sparse_tree_test');
+const createDb = async (levelUp, hasher, name, depth) => {
+    return await newTree(SparseTree, levelUp, hasher, name, depth);
+};
+const createFromName = async (levelUp, hasher, name) => {
+    return await loadTree(SparseTree, levelUp, hasher, name);
+};
+const TEST_TREE_DEPTH = 3;
+treeTestSuite('SparseTree', createDb, createFromName);
+standardBasedTreeTestSuite('SparseTree', createDb);
+describe('SparseTreeSpecific', () => {
+    let wasm;
+    let pedersen;
+    beforeEach(async () => {
+        wasm = await CircuitsWasm.get();
+        pedersen = new Pedersen(wasm);
+    });
+    it('throws when index is bigger than (2^DEPTH - 1) ', async () => {
+        const db = levelup(createMemDown());
+        const depth = 32;
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const index = 2n ** BigInt(depth);
+        await expect(tree.updateLeaf(Buffer.alloc(32), index)).rejects.toThrow();
+    });
+    it('updating non-empty leaf does not change tree size', async () => {
+        const depth = 32;
+        const maxIndex = 2 ** depth - 1;
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const randomIndex = BigInt(Math.floor(Math.random() * maxIndex));
+        expect(tree.getNumLeaves(false)).toEqual(0n);
+        // Insert a leaf
+        await tree.updateLeaf(randomBytes(32), randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+        // Update a leaf
+        await tree.updateLeaf(randomBytes(32), randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+    });
+    it('deleting leaf decrements tree size', async () => {
+        const depth = 254;
+        const maxIndex = 2 ** depth - 1;
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const randomIndex = BigInt(Math.floor(Math.random() * maxIndex));
+        expect(tree.getNumLeaves(false)).toEqual(0n);
+        // Insert a leaf
+        await tree.updateLeaf(randomBytes(32), randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+        // Delete a leaf
+        await tree.updateLeaf(INITIAL_LEAF, randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(0n);
+    });
+    it('should have correct root and sibling path after in a "non-append-only" way', async () => {
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', 3);
+        const level2ZeroHash = pedersen.compress(INITIAL_LEAF, INITIAL_LEAF);
+        const level1ZeroHash = pedersen.compress(level2ZeroHash, level2ZeroHash);
+        expect(tree.getNumLeaves(false)).toEqual(0n);
+        expect(tree.getRoot(false)).toEqual(pedersen.compress(level1ZeroHash, level1ZeroHash));
+        // Insert leaf at index 3
+        let level1LeftHash;
+        const leafAtIndex3 = randomBytes(32);
+        {
+            await tree.updateLeaf(leafAtIndex3, 3n);
+            expect(tree.getNumLeaves(true)).toEqual(1n);
+            const level2Hash = pedersen.compress(INITIAL_LEAF, leafAtIndex3);
+            level1LeftHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1ZeroHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level2ZeroHash, level1ZeroHash]));
+        }
+        // Insert leaf at index 6
+        let level1RightHash;
+        {
+            const leafAtIndex6 = randomBytes(32);
+            await tree.updateLeaf(leafAtIndex6, 6n);
+            expect(tree.getNumLeaves(true)).toEqual(2n);
+            const level2Hash = pedersen.compress(leafAtIndex6, INITIAL_LEAF);
+            level1RightHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1RightHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(6n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level2ZeroHash, level1LeftHash]));
+        }
+        // Insert leaf at index 2
+        const leafAtIndex2 = randomBytes(32);
+        {
+            await tree.updateLeaf(leafAtIndex2, 2n);
+            expect(tree.getNumLeaves(true)).toEqual(3n);
+            const level2Hash = pedersen.compress(leafAtIndex2, leafAtIndex3);
+            level1LeftHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1RightHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(2n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [leafAtIndex3, level2ZeroHash, level1RightHash]));
+        }
+        // Updating leaf at index 3
+        {
+            const updatedLeafAtIndex3 = randomBytes(32);
+            await tree.updateLeaf(updatedLeafAtIndex3, 3n);
+            expect(tree.getNumLeaves(true)).toEqual(3n);
+            const level2Hash = pedersen.compress(leafAtIndex2, updatedLeafAtIndex3);
+            level1LeftHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1RightHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [leafAtIndex2, level2ZeroHash, level1RightHash]));
+        }
+    });
+    it.skip('measures time of inserting 1000 leaves at random positions for depth 254', async () => {
+        const depth = 254;
+        const maxIndex = 2 ** depth - 1;
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const leaves = Array.from({ length: 1000 }).map(() => randomBytes(32));
+        const indices = Array.from({ length: 1000 }).map(() => BigInt(Math.floor(Math.random() * maxIndex)));
+        const start = Date.now();
+        await Promise.all(leaves.map((leaf, i) => tree.updateLeaf(leaf, indices[i])));
+        const end = Date.now();
+        log(`Inserting 1000 leaves at random positions for depth 254 took ${end - start}ms`);
+    }, 300000);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sparse_tree.test.js","sourceRoot":"","sources":["../../src/sparse_tree/sparse_tree.test.ts"],"names":[],"mappings":"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"}