@feelyourprotocol/binarytree 8141.0.0

package/dist/cjs/node/stemNode.d.ts

@@ -0,0 +1,34 @@
+import { BinaryNodeType } from './types.ts';
+import type { BinaryNodeOptions } from './types.ts';
+export declare class StemBinaryNode {
+    stem: Uint8Array;
+    values: (Uint8Array | null)[];
+    type: 1;
+    constructor(options: BinaryNodeOptions[typeof BinaryNodeType.Stem]);
+    static fromRawNode(rawNode: Uint8Array[]): StemBinaryNode;
+    /**
+     * Generates a new Stem node
+     * @param stem the 31 byte stem corresponding to the where the stem node is located in the tree
+     * @returns a new Stem node
+     */
+    static create(stem: Uint8Array): StemBinaryNode;
+    getValue(index: number): Uint8Array | null;
+    setValue(index: number, value: Uint8Array | null): void;
+    /**
+     * @returns the RLP serialized node
+     */
+    serialize(): Uint8Array;
+    /**
+     * Returns the raw serialized representation of the node as an array of Uint8Arrays.
+     * The returned array is constructed as follows:
+     * - The first element is a Uint8Array containing a single byte that represents the node type,
+     * - The second element is the node's `stem` property.
+     * - The remaining elements are derived from the node's `values` array:
+     *   - For each value, if it is `null`, it is converted to an empty Uint8Array.
+     *   - Otherwise, the value is included as-is.
+     *
+     * @returns {Uint8Array[]} An array of Uint8Arrays representing the node's raw data.
+     */
+    raw(): Uint8Array[];
+}
+//# sourceMappingURL=stemNode.d.ts.map

package/dist/cjs/node/stemNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stemNode.d.ts","sourceRoot":"","sources":["../../../src/node/stemNode.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAc,MAAM,YAAY,CAAA;AAEvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,qBAAa,cAAc;IAClB,IAAI,EAAE,UAAU,CAAA;IAChB,MAAM,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAA;IAE7B,IAAI,IAAsB;gBAErB,OAAO,EAAE,iBAAiB,CAAC,OAAO,cAAc,CAAC,IAAI,CAAC;IAKlE,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,cAAc;IAkBzD;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc;IAK/C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAI1C,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI;IAIvD;;OAEG;IACH,SAAS,IAAI,UAAU;IAIvB;;;;;;;;;;OAUG;IACH,GAAG,IAAI,UAAU,EAAE;CAcpB"}

package/dist/cjs/node/stemNode.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StemBinaryNode = void 0;
+const rlp_1 = require("@feelyourprotocol/rlp");
+const util_1 = require("@feelyourprotocol/util");
+const types_ts_1 = require("./types.js");
+class StemBinaryNode {
+    constructor(options) {
+        this.type = types_ts_1.BinaryNodeType.Stem;
+        this.stem = options.stem;
+        this.values = options.values ?? new Array(256).fill(null);
+    }
+    static fromRawNode(rawNode) {
+        const nodeType = rawNode[0][0];
+        if (nodeType !== types_ts_1.BinaryNodeType.Stem) {
+            throw (0, util_1.EthereumJSErrorWithoutCode)('Invalid node type');
+        }
+        // The length of the rawNode should be the # of values (node width) + 2 for the node type and the stem
+        if (rawNode.length !== types_ts_1.NODE_WIDTH + 2) {
+            throw (0, util_1.EthereumJSErrorWithoutCode)('Invalid node length');
+        }
+        const stem = rawNode[1];
+        const rawValues = rawNode.slice(2, rawNode.length);
+        const values = rawValues.map((el) => (el.length === 0 ? null : el));
+        return new StemBinaryNode({ stem, values });
+    }
+    /**
+     * Generates a new Stem node
+     * @param stem the 31 byte stem corresponding to the where the stem node is located in the tree
+     * @returns a new Stem node
+     */
+    static create(stem) {
+        return new StemBinaryNode({ stem });
+    }
+    // Retrieve the value at the provided index from the values array
+    getValue(index) {
+        return this.values[index];
+    }
+    setValue(index, value) {
+        this.values[index] = value;
+    }
+    /**
+     * @returns the RLP serialized node
+     */
+    serialize() {
+        return rlp_1.RLP.encode(this.raw());
+    }
+    /**
+     * Returns the raw serialized representation of the node as an array of Uint8Arrays.
+     * The returned array is constructed as follows:
+     * - The first element is a Uint8Array containing a single byte that represents the node type,
+     * - The second element is the node's `stem` property.
+     * - The remaining elements are derived from the node's `values` array:
+     *   - For each value, if it is `null`, it is converted to an empty Uint8Array.
+     *   - Otherwise, the value is included as-is.
+     *
+     * @returns {Uint8Array[]} An array of Uint8Arrays representing the node's raw data.
+     */
+    raw() {
+        return [
+            new Uint8Array([types_ts_1.BinaryNodeType.Stem]),
+            this.stem,
+            ...this.values.map((val) => {
+                switch (val) {
+                    case null:
+                        return new Uint8Array();
+                    default:
+                        return val;
+                }
+            }),
+        ];
+    }
+}
+exports.StemBinaryNode = StemBinaryNode;
+//# sourceMappingURL=stemNode.js.map

package/dist/cjs/node/stemNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stemNode.js","sourceRoot":"","sources":["../../../src/node/stemNode.ts"],"names":[],"mappings":";;;AAAA,yCAAqC;AACrC,2CAA6D;AAE7D,yCAAuD;AAIvD,MAAa,cAAc;IAMzB,YAAY,OAAsD;QAF3D,SAAI,GAAG,yBAAc,CAAC,IAAI,CAAA;QAG/B,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;QACxB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC3D,CAAC;IAED,MAAM,CAAC,WAAW,CAAC,OAAqB;QACtC,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QAC9B,IAAI,QAAQ,KAAK,yBAAc,CAAC,IAAI,EAAE,CAAC;YACrC,MAAM,IAAA,iCAA0B,EAAC,mBAAmB,CAAC,CAAA;QACvD,CAAC;QAED,sGAAsG;QACtG,IAAI,OAAO,CAAC,MAAM,KAAK,qBAAU,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,IAAA,iCAA0B,EAAC,qBAAqB,CAAC,CAAA;QACzD,CAAC;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QACvB,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;QAClD,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QAEnE,OAAO,IAAI,cAAc,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAA;IAC7C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,IAAgB;QAC5B,OAAO,IAAI,cAAc,CAAC,EAAE,IAAI,EAAE,CAAC,CAAA;IACrC,CAAC;IAED,iEAAiE;IACjE,QAAQ,CAAC,KAAa;QACpB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;IAED,QAAQ,CAAC,KAAa,EAAE,KAAwB;QAC9C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAA;IAC5B,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,SAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAA;IAC/B,CAAC;IAED;;;;;;;;;;OAUG;IACH,GAAG;QACD,OAAO;YACL,IAAI,UAAU,CAAC,CAAC,yBAAc,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,CAAC,IAAI;YACT,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;gBACzB,QAAQ,GAAG,EAAE,CAAC;oBACZ,KAAK,IAAI;wBACP,OAAO,IAAI,UAAU,EAAE,CAAA;oBACzB;wBACE,OAAO,GAAG,CAAA;gBACd,CAAC;YACH,CAAC,CAAC;SACH,CAAA;IACH,CAAC;CACF;AA/ED,wCA+EC"}

package/dist/cjs/node/types.d.ts

@@ -0,0 +1,35 @@
+import type { InternalBinaryNode } from './internalNode.ts';
+import type { StemBinaryNode } from './stemNode.ts';
+export type BinaryNodeType = (typeof BinaryNodeType)[keyof typeof BinaryNodeType];
+export declare const BinaryNodeType: {
+    readonly Internal: 0;
+    readonly Stem: 1;
+};
+export interface TypedBinaryNode {
+    [BinaryNodeType.Internal]: InternalBinaryNode;
+    [BinaryNodeType.Stem]: StemBinaryNode;
+}
+export type BinaryNode = TypedBinaryNode[BinaryNodeType];
+/**
+ * @dev A child node in a binary tree internal node.
+ * @param hash The hash of the child node.
+ * @param path The path to the child node, in bits.
+ * */
+export type ChildBinaryNode = {
+    hash: Uint8Array;
+    path: number[];
+};
+interface InternalBinaryNodeOptions {
+    children?: (ChildBinaryNode | null)[];
+}
+interface StemBinaryNodeOptions {
+    stem: Uint8Array;
+    values?: (Uint8Array | null)[];
+}
+export interface BinaryNodeOptions {
+    [BinaryNodeType.Internal]: InternalBinaryNodeOptions;
+    [BinaryNodeType.Stem]: StemBinaryNodeOptions;
+}
+export declare const NODE_WIDTH = 256;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/node/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/node/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAA;AACjF,eAAO,MAAM,cAAc;;;CAGjB,CAAA;AAEV,MAAM,WAAW,eAAe;IAC9B,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7C,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,cAAc,CAAA;CACtC;AAED,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC,cAAc,CAAC,CAAA;AAExD;;;;KAIK;AACL,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,UAAU,CAAA;IAChB,IAAI,EAAE,MAAM,EAAE,CAAA;CACf,CAAA;AAED,UAAU,yBAAyB;IACjC,QAAQ,CAAC,EAAE,CAAC,eAAe,GAAG,IAAI,CAAC,EAAE,CAAA;CACtC;AAED,UAAU,qBAAqB;IAC7B,IAAI,EAAE,UAAU,CAAA;IAChB,MAAM,CAAC,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,CAAA;CAC/B;AAED,MAAM,WAAW,iBAAiB;IAChC,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,yBAAyB,CAAA;IACpD,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,qBAAqB,CAAA;CAC7C;AAED,eAAO,MAAM,UAAU,MAAM,CAAA"}

package/dist/cjs/node/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODE_WIDTH = exports.BinaryNodeType = void 0;
+exports.BinaryNodeType = {
+    Internal: 0,
+    Stem: 1,
+};
+exports.NODE_WIDTH = 256;
+//# sourceMappingURL=types.js.map

package/dist/cjs/node/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/node/types.ts"],"names":[],"mappings":";;;AAIa,QAAA,cAAc,GAAG;IAC5B,QAAQ,EAAE,CAAC;IACX,IAAI,EAAE,CAAC;CACC,CAAA;AAiCG,QAAA,UAAU,GAAG,GAAG,CAAA"}

package/dist/cjs/node/util.d.ts

@@ -0,0 +1,9 @@
+import { InternalBinaryNode } from './internalNode.ts';
+import { StemBinaryNode } from './stemNode.ts';
+import { type BinaryNode } from './types.ts';
+export declare function decodeRawBinaryNode(raw: Uint8Array[]): BinaryNode;
+export declare function decodeBinaryNode(raw: Uint8Array): BinaryNode;
+export declare function isRawBinaryNode(node: Uint8Array | Uint8Array[]): node is Uint8Array[];
+export declare function isInternalBinaryNode(node: BinaryNode): node is InternalBinaryNode;
+export declare function isStemBinaryNode(node: BinaryNode): node is StemBinaryNode;
+//# sourceMappingURL=util.d.ts.map

package/dist/cjs/node/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/node/util.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,YAAY,CAAA;AAE5D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,UAAU,CAUjE;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,UAAU,cAM/C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,GAAG,IAAI,IAAI,UAAU,EAAE,CAErF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,IAAI,kBAAkB,CAEjF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,IAAI,cAAc,CAEzE"}

package/dist/cjs/node/util.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeRawBinaryNode = decodeRawBinaryNode;
+exports.decodeBinaryNode = decodeBinaryNode;
+exports.isRawBinaryNode = isRawBinaryNode;
+exports.isInternalBinaryNode = isInternalBinaryNode;
+exports.isStemBinaryNode = isStemBinaryNode;
+const rlp_1 = require("@feelyourprotocol/rlp");
+const util_1 = require("@feelyourprotocol/util");
+const internalNode_ts_1 = require("./internalNode.js");
+const stemNode_ts_1 = require("./stemNode.js");
+const types_ts_1 = require("./types.js");
+function decodeRawBinaryNode(raw) {
+    const nodeType = raw[0][0];
+    switch (nodeType) {
+        case types_ts_1.BinaryNodeType.Internal:
+            return internalNode_ts_1.InternalBinaryNode.fromRawNode(raw);
+        case types_ts_1.BinaryNodeType.Stem:
+            return stemNode_ts_1.StemBinaryNode.fromRawNode(raw);
+        default:
+            throw (0, util_1.EthereumJSErrorWithoutCode)('Invalid node type');
+    }
+}
+function decodeBinaryNode(raw) {
+    const decoded = rlp_1.RLP.decode(Uint8Array.from(raw));
+    if (!Array.isArray(decoded)) {
+        throw (0, util_1.EthereumJSErrorWithoutCode)('Invalid node');
+    }
+    return decodeRawBinaryNode(decoded);
+}
+function isRawBinaryNode(node) {
+    return Array.isArray(node) && !(node instanceof Uint8Array);
+}
+function isInternalBinaryNode(node) {
+    return node.type === types_ts_1.BinaryNodeType.Internal;
+}
+function isStemBinaryNode(node) {
+    return node.type === types_ts_1.BinaryNodeType.Stem;
+}
+//# sourceMappingURL=util.js.map

package/dist/cjs/node/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../src/node/util.ts"],"names":[],"mappings":";;AAOA,kDAUC;AAED,4CAMC;AAED,0CAEC;AAED,oDAEC;AAED,4CAEC;AArCD,yCAAqC;AACrC,2CAA6D;AAE7D,uDAAsD;AACtD,+CAA8C;AAC9C,yCAA4D;AAE5D,SAAgB,mBAAmB,CAAC,GAAiB;IACnD,MAAM,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC1B,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,yBAAc,CAAC,QAAQ;YAC1B,OAAO,oCAAkB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;QAC5C,KAAK,yBAAc,CAAC,IAAI;YACtB,OAAO,4BAAc,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;QACxC;YACE,MAAM,IAAA,iCAA0B,EAAC,mBAAmB,CAAC,CAAA;IACzD,CAAC;AACH,CAAC;AAED,SAAgB,gBAAgB,CAAC,GAAe;IAC9C,MAAM,OAAO,GAAG,SAAG,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAiB,CAAA;IAChE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAA,iCAA0B,EAAC,cAAc,CAAC,CAAA;IAClD,CAAC;IACD,OAAO,mBAAmB,CAAC,OAAO,CAAC,CAAA;AACrC,CAAC;AAED,SAAgB,eAAe,CAAC,IAA+B;IAC7D,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,YAAY,UAAU,CAAC,CAAA;AAC7D,CAAC;AAED,SAAgB,oBAAoB,CAAC,IAAgB;IACnD,OAAO,IAAI,CAAC,IAAI,KAAK,yBAAc,CAAC,QAAQ,CAAA;AAC9C,CAAC;AAED,SAAgB,gBAAgB,CAAC,IAAgB;IAC/C,OAAO,IAAI,CAAC,IAAI,KAAK,yBAAc,CAAC,IAAI,CAAA;AAC1C,CAAC"}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/cjs/proof.d.ts

@@ -0,0 +1,16 @@
+import type { BinaryTree } from './binaryTree.ts';
+/**
+ * Saves the nodes from a proof into the tree.
+ * @param proof
+ */
+export declare function binaryTreeFromProof(proof: Uint8Array[]): Promise<BinaryTree>;
+/**
+ * Verifies a proof.
+ * @param rootHash
+ * @param key
+ * @param proof
+ * @throws If proof is found to be invalid.
+ * @returns The value from the key, or null if valid proof of non-existence.
+ */
+export declare function verifyBinaryProof(rootHash: Uint8Array, key: Uint8Array, proof: Uint8Array[]): Promise<Uint8Array | null>;
+//# sourceMappingURL=proof.d.ts.map

package/dist/cjs/proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../src/proof.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAIjD;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAUlF;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,UAAU,EACpB,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,UAAU,EAAE,GAClB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAgB5B"}

package/dist/cjs/proof.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binaryTreeFromProof = binaryTreeFromProof;
+exports.verifyBinaryProof = verifyBinaryProof;
+const util_1 = require("@feelyourprotocol/util");
+const constructors_ts_1 = require("./constructors.js");
+const index_ts_1 = require("./node/index.js");
+/**
+ * Saves the nodes from a proof into the tree.
+ * @param proof
+ */
+async function binaryTreeFromProof(proof) {
+    const proofTrie = await (0, constructors_ts_1.createBinaryTree)();
+    const putStack = proof.map((bytes) => {
+        const node = (0, index_ts_1.decodeBinaryNode)(bytes);
+        return [proofTrie['merkelize'](node), node];
+    });
+    await proofTrie.saveStack(putStack);
+    const root = putStack[0][0];
+    proofTrie.root(root);
+    return proofTrie;
+}
+/**
+ * Verifies a proof.
+ * @param rootHash
+ * @param key
+ * @param proof
+ * @throws If proof is found to be invalid.
+ * @returns The value from the key, or null if valid proof of non-existence.
+ */
+async function verifyBinaryProof(rootHash, key, proof) {
+    const proofTrie = await binaryTreeFromProof(proof);
+    if (!(0, util_1.equalsBytes)(proofTrie.root(), rootHash)) {
+        throw (0, util_1.EthereumJSErrorWithoutCode)('rootHash does not match proof root');
+    }
+    const [value] = await proofTrie.get(key.slice(0, 31), [key[31]]);
+    const valueNode = (0, index_ts_1.decodeBinaryNode)(proof[proof.length - 1]);
+    const expectedValue = valueNode.values[key[31]];
+    if (!expectedValue) {
+        if (value) {
+            throw (0, util_1.EthereumJSErrorWithoutCode)('Proof is invalid');
+        }
+    }
+    else if (value && !(0, util_1.equalsBytes)(value, expectedValue)) {
+        throw (0, util_1.EthereumJSErrorWithoutCode)('Proof is invalid');
+    }
+    return value;
+}
+//# sourceMappingURL=proof.js.map

package/dist/cjs/proof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof.js","sourceRoot":"","sources":["../../src/proof.ts"],"names":[],"mappings":";;AAaA,kDAUC;AAUD,8CAoBC;AArDD,2CAA0E;AAE1E,uDAAoD;AACpD,8CAAkD;AAMlD;;;GAGG;AACI,KAAK,UAAU,mBAAmB,CAAC,KAAmB;IAC3D,MAAM,SAAS,GAAG,MAAM,IAAA,kCAAgB,GAAE,CAAA;IAC1C,MAAM,QAAQ,GAA+B,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC/D,MAAM,IAAI,GAAG,IAAA,2BAAgB,EAAC,KAAK,CAAC,CAAA;QACpC,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAA;IAC7C,CAAC,CAAC,CAAA;IACF,MAAM,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;IACnC,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC3B,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACpB,OAAO,SAAS,CAAA;AAClB,CAAC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,iBAAiB,CACrC,QAAoB,EACpB,GAAe,EACf,KAAmB;IAEnB,MAAM,SAAS,GAAG,MAAM,mBAAmB,CAAC,KAAK,CAAC,CAAA;IAClD,IAAI,CAAC,IAAA,kBAAW,EAAC,SAAS,CAAC,IAAI,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAA,iCAA0B,EAAC,oCAAoC,CAAC,CAAA;IACxE,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAChE,MAAM,SAAS,GAAG,IAAA,2BAAgB,EAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAmB,CAAA;IAC7E,MAAM,aAAa,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAA;IAC/C,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,IAAA,iCAA0B,EAAC,kBAAkB,CAAC,CAAA;QACtD,CAAC;IACH,CAAC;SAAM,IAAI,KAAK,IAAI,CAAC,IAAA,kBAAW,EAAC,KAAK,EAAE,aAAa,CAAC,EAAE,CAAC;QACvD,MAAM,IAAA,iCAA0B,EAAC,kBAAkB,CAAC,CAAA;IACtD,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/cjs/types.d.ts

@@ -0,0 +1,45 @@
+import type { DB, ValueEncoding } from '@feelyourprotocol/util';
+export interface BinaryTreeOpts {
+    /**
+     * A database instance.
+     */
+    db: DB<string, string | Uint8Array>;
+    /**
+     * A `Uint8Array` for the root of a previously stored tree
+     */
+    root?: Uint8Array;
+    /**
+     * Store the root inside the database after every `write` operation
+     */
+    useRootPersistence: boolean;
+    /**
+     * LRU cache for tree nodes to allow for faster node retrieval.
+     *
+     * Default: 0 (deactivated)
+     */
+    cacheSize: number;
+    /**
+     * Hash function used for hashing the tree nodes.
+     */
+    hashFunction: (msg: Uint8Array) => Uint8Array;
+}
+export interface CheckpointDBOpts {
+    /**
+     * A database instance.
+     */
+    db: DB<string, string | Uint8Array>;
+    /**
+     * ValueEncoding of the database (the values which are `put`/`get` in the db are of this type). Defaults to `string`
+     */
+    valueEncoding?: ValueEncoding;
+    /**
+     * Cache size (default: 0)
+     */
+    cacheSize?: number;
+}
+export type Checkpoint = {
+    keyValueMap: Map<string, Uint8Array | undefined>;
+    root: Uint8Array;
+};
+export declare const ROOT_DB_KEY: Uint8Array<ArrayBufferLike>;
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEzD,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAA;IAEnC;;OAEG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;IAEjB;;OAEG;IACH,kBAAkB,EAAE,OAAO,CAAA;IAE3B;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAA;IAEjB;;OAEG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,UAAU,CAAA;CAC9C;AAED,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAA;IAEnC;;OAEG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;IAE7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,UAAU,GAAG;IAGvB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC,CAAA;IAChD,IAAI,EAAE,UAAU,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,WAAW,6BAA0B,CAAA"}

package/dist/cjs/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_DB_KEY = void 0;
+const util_1 = require("@feelyourprotocol/util");
+exports.ROOT_DB_KEY = (0, util_1.utf8ToBytes)('__root__');
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";;;AAAA,2CAA8C;AAyDjC,QAAA,WAAW,GAAG,IAAA,kBAAW,EAAC,UAAU,CAAC,CAAA"}

package/dist/cjs/util.d.ts

@@ -0,0 +1,17 @@
+import { type PrefixedHexString } from '@feelyourprotocol/util';
+import type { BinaryTree } from './binaryTree.ts';
+/**
+ * Recursively walks down the tree from a given starting node and returns all the leaf values
+ * @param tree - The binary tree
+ * @param startingNode - The starting node
+ * @returns An array of key-value pairs containing the tree keys and associated values
+ */
+export declare const dumpLeafValues: (tree: BinaryTree, startingNode: Uint8Array) => Promise<[PrefixedHexString, PrefixedHexString][] | undefined>;
+/**
+ * Recursively walks down the tree from a given starting node and returns all the node paths and hashes
+ * @param tree - The binary tree
+ * @param startingNode - The starting node
+ * @returns An array of key-value pairs containing the tree paths and associated hashes
+ */
+export declare const dumpNodeHashes: (tree: BinaryTree, startingNode: Uint8Array) => Promise<[string, PrefixedHexString][] | undefined>;
+//# sourceMappingURL=util.d.ts.map

package/dist/cjs/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,kBAAkB,CAAA;AAM/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAGjD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,UAAU,EAChB,cAAc,UAAU,KACvB,OAAO,CAAC,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,EAAE,GAAG,SAAS,CAsB9D,CAAA;AACD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,UAAU,EAChB,cAAc,UAAU,KACvB,OAAO,CAAC,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAAE,GAAG,SAAS,CA6BnD,CAAA"}

package/dist/cjs/util.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dumpNodeHashes = exports.dumpLeafValues = void 0;
+const util_1 = require("@feelyourprotocol/util");
+const internalNode_ts_1 = require("./node/internalNode.js");
+const stemNode_ts_1 = require("./node/stemNode.js");
+const util_ts_1 = require("./node/util.js");
+/**
+ * Recursively walks down the tree from a given starting node and returns all the leaf values
+ * @param tree - The binary tree
+ * @param startingNode - The starting node
+ * @returns An array of key-value pairs containing the tree keys and associated values
+ */
+const dumpLeafValues = async (tree, startingNode) => {
+    if ((0, util_1.equalsBytes)(startingNode, tree.EMPTY_TREE_ROOT) === true)
+        return;
+    // Retrieve starting node from DB
+    const rawNode = await tree['_db'].get(startingNode);
+    if (rawNode === undefined)
+        return;
+    const node = (0, util_ts_1.decodeBinaryNode)(rawNode);
+    const entries = [];
+    if (node instanceof stemNode_ts_1.StemBinaryNode) {
+        for (const [idx, val] of node.values.entries()) {
+            if (val !== null) {
+                entries.push([(0, util_1.bytesToHex)((0, util_1.concatBytes)(node.stem, Uint8Array.from([idx]))), (0, util_1.bytesToHex)(val)]);
+            }
+        }
+        return entries;
+    }
+    else {
+        const childPaths = node.children
+            .filter((value) => value !== null)
+            .map((value) => (0, exports.dumpLeafValues)(tree, value.hash));
+        const res = (await Promise.all(childPaths)).filter((val) => val !== undefined);
+        return res.flat(1);
+    }
+};
+exports.dumpLeafValues = dumpLeafValues;
+/**
+ * Recursively walks down the tree from a given starting node and returns all the node paths and hashes
+ * @param tree - The binary tree
+ * @param startingNode - The starting node
+ * @returns An array of key-value pairs containing the tree paths and associated hashes
+ */
+const dumpNodeHashes = async (tree, startingNode) => {
+    let entries = [];
+    // Retrieve starting node from DB
+    const rawNode = await tree['_db'].get(startingNode);
+    if (rawNode === undefined)
+        return;
+    const node = (0, util_ts_1.decodeBinaryNode)(rawNode);
+    // If current node is root, push '0x' for path and node hash for commitment
+    (0, util_1.equalsBytes)(startingNode, tree.root()) && entries.push(['0x', (0, util_1.bytesToHex)(startingNode)]);
+    if (node instanceof internalNode_ts_1.InternalBinaryNode) {
+        const children = node.children.filter((value) => value !== null);
+        // Push non-null children paths and hashes
+        for (const child of children) {
+            entries.push([child.path.join(''), (0, util_1.bytesToHex)(child.hash)]);
+        }
+        // Recursively call dumpNodeHashes on each child node
+        const childPaths = (await Promise.all(children.map((value) => (0, exports.dumpNodeHashes)(tree, value.hash))))
+            .filter((val) => val !== undefined)
+            .flat(1);
+        // Add all child paths and hashes to entries
+        entries = [...entries, ...childPaths];
+    }
+    return entries;
+};
+exports.dumpNodeHashes = dumpNodeHashes;
+//# sourceMappingURL=util.js.map

package/dist/cjs/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"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"}

package/dist/esm/binaryTree.d.ts

@@ -0,0 +1,167 @@
+import { Lock } from '@feelyourprotocol/util';
+import { CheckpointDB } from './db/index.ts';
+import { StemBinaryNode } from './node/stemNode.ts';
+import { type BinaryTreeOpts } from './types.ts';
+import type { Debugger } from 'debug';
+import type { BinaryNode } from './node/types.ts';
+interface Path {
+    node: BinaryNode | null;
+    remaining: number[];
+    stack: Array<[BinaryNode, number[]]>;
+}
+/**
+ * The basic binary tree interface, use with `import { BinaryTree } from '@feelyourprotocol/binarytree'`.
+ *
+ * A BinaryTree object can be created with the constructor method:
+ *
+ * - {@link createBinaryTree}
+ */
+export declare class BinaryTree {
+    /** The options for instantiating the binary tree */
+    protected _opts: BinaryTreeOpts;
+    /** The root for an empty tree */
+    EMPTY_TREE_ROOT: Uint8Array;
+    protected _db: CheckpointDB;
+    protected _hashLen: number;
+    protected _lock: Lock;
+    protected _root: Uint8Array;
+    protected DEBUG: boolean;
+    protected _debug: Debugger;
+    protected debug: (...args: any) => void;
+    /**
+     * Creates a new binary tree.
+     * @param opts Options for instantiating the binary tree
+     *
+     * Note: in most cases, the static {@link createBinaryTree} constructor should be used. It uses the same API but provides sensible defaults
+     */
+    constructor(opts: BinaryTreeOpts);
+    /**
+     * Gets and/or Sets the current root of the `tree`
+     */
+    root(value?: Uint8Array | null): Uint8Array;
+    /**
+     * Checks if a given root exists.
+     */
+    checkRoot(root: Uint8Array): Promise<boolean>;
+    /**
+     * Gets values at a given binary tree `stem` and set of suffixes
+     * @param stem - the stem of the stem node where we're seeking values
+     * @param suffixes - an array of suffixes corresponding to the values desired
+     * @returns A Promise that resolves to an array of `Uint8Array`s or `null` depending on if values were found.
+     * If the stem is not found, will return an empty array.
+     */
+    get(stem: Uint8Array, suffixes: number[]): Promise<(Uint8Array | null)[]>;
+    /**
+     * Stores a given `value` at the given `key` or performs a deletion if `value` is null.
+     * @param stem - the stem (must be 31 bytes) to store the value at.
+     * @param suffixes - array of suffixes at which to store individual values.
+     * @param values - the value(s) to store (or null for deletion).
+     * @returns A Promise that resolves once the value is stored.
+     */
+    put(stem: Uint8Array, suffixes: number[], values: (Uint8Array | null)[]): Promise<void>;
+    /**
+     * Helper method for updating or creating the parent internal node for a given stem node.
+     * If the nearest node is a stem node with a different stem, a new internal node is created
+     * to branch at the first differing bit.
+     * If the nearest node is an internal node, its child reference is updated.
+     *
+     * @param stemNode - The child stem node that will be referenced by the new/updated internal node.
+     * @param nearestNode - The nearest node to the new stem node.
+     * @param pathToNode - The path (in bits) to `nearestNode` as known from the trie.
+     * @returns An array of nodes and their partial paths from the new stem node to the branch parent node
+     *          or `undefined` if no changes were made.
+     */
+    updateBranch(stemNode: StemBinaryNode, nearestNode: BinaryNode, pathToNode: number[], pathToParent: number[]): {
+        node: BinaryNode;
+        parentPath: number[];
+    }[] | undefined;
+    /**
+     * Tries to find a path to the node for the given key.
+     * It returns a `Path` object containing:
+     *   - `node`: the found node (if any),
+     *   - `stack`: an array of tuples [node, path] representing the nodes encountered,
+     *   - `remaining`: the bits of the key that were not matched.
+     *
+     * @param keyInBytes - the search key as a byte array.
+     * @returns A Promise that resolves to a Path object.
+     */
+    findPath(keyInBytes: Uint8Array): Promise<Path>;
+    /**
+     * Deletes a given `key` from the tree.
+     * @param stem - the stem of the stem node to delete from
+     * @param suffixes - the suffixes to delete
+     * @returns A Promise that resolves once the key is deleted.
+     */
+    del(stem: Uint8Array, suffixes: number[]): Promise<void>;
+    /**
+     * Create empty root node for initializing an empty tree.
+     */
+    createRootNode(): Promise<void>;
+    /**
+     * Creates the initial node from an empty tree.
+     * @private
+     */
+    protected _createInitialNode(stem: Uint8Array, indexes: number[], values: (Uint8Array | null)[]): Promise<void>;
+    /**
+     * Saves a stack of nodes to the database.
+     *
+     * @param putStack - an array of tuples of keys (the partial path of the node in the trie) and nodes (BinaryNodes)
+     */
+    saveStack(putStack: [Uint8Array, BinaryNode | null][]): Promise<void>;
+    /**
+     * Creates a proof from a tree and key that can be verified using {@link BinaryTree.verifyBinaryProof}.
+     * @param key a 32 byte binary tree key (31 byte stem + 1 byte suffix)
+     */
+    createBinaryProof(key: Uint8Array): Promise<Uint8Array[]>;
+    /**
+     * The `data` event is given an `Object` that has two properties; the `key` and the `value`. Both should be Uint8Arrays.
+     * @return Returns a [stream](https://nodejs.org/dist/latest-v12.x/docs/api/stream.html#stream_class_stream_readable) of the contents of the `tree`
+     */
+    createReadStream(): any;
+    /**
+     * Returns a copy of the underlying tree.
+     *
+     * Note on db: the copy will create a reference to the
+     * same underlying database.
+     *
+     * Note on cache: for memory reasons a copy will not
+     * recreate a new LRU cache but initialize with cache
+     * being deactivated.
+     *
+     * @param includeCheckpoints - If true and during a checkpoint, the copy will contain the checkpointing metadata and will use the same scratch as underlying db.
+     */
+    shallowCopy(includeCheckpoints?: boolean): BinaryTree;
+    /**
+     * Persists the root hash in the underlying database
+     */
+    persistRoot(): Promise<void>;
+    /**
+     * Is the tree during a checkpoint phase?
+     */
+    hasCheckpoints(): boolean;
+    /**
+     * Creates a checkpoint that can later be reverted to or committed.
+     * After this is called, all changes can be reverted until `commit` is called.
+     */
+    checkpoint(): void;
+    /**
+     * Commits a checkpoint to disk, if current checkpoint is not nested.
+     * If nested, only sets the parent checkpoint as current checkpoint.
+     * @throws If not during a checkpoint phase
+     */
+    commit(): Promise<void>;
+    /**
+     * Reverts the tree to the state it was at when `checkpoint` was first called.
+     * If during a nested checkpoint, sets root to most recent checkpoint, and sets
+     * parent checkpoint as current.
+     */
+    revert(): Promise<void>;
+    /**
+     * Flushes all checkpoints, restoring the initial checkpoint state.
+     */
+    flushCheckpoints(): void;
+    protected hash(msg: Uint8Array | null): Uint8Array;
+    protected merkelize(node: BinaryNode | null): Uint8Array;
+}
+export {};
+//# sourceMappingURL=binaryTree.d.ts.map