@proto-kit/common 0.1.1-develop.165 → 0.1.1-develop.1661

package/dist/trees/lmt/AbstractLinkedMerkleTree.d.ts

@@ -0,0 +1,288 @@
+import { Bool, Field } from "o1js";
+import { RollupMerkleTree } from "../sparse/RollupMerkleTree";
+import { TypedClass } from "../../types";
+import { MerkleTreeStore } from "../sparse/MerkleTreeStore";
+import { LinkedLeafStore } from "./LinkedLeafStore";
+import { LinkedLeafStruct } from "./LinkedMerkleTreeTypes";
+declare const RollupMerkleTreeWitness_base: TypedClass<import("../sparse/RollupMerkleTree").AbstractMerkleWitness> & typeof import("../sparse/RollupMerkleTree").StructTemplate & {
+    dummy: () => import("../sparse/RollupMerkleTree").AbstractMerkleWitness;
+};
+declare class RollupMerkleTreeWitness extends RollupMerkleTreeWitness_base {
+}
+type LinkedMerkleWitnessValue = {
+    leaf: LinkedLeafStruct;
+    merkleWitness: RollupMerkleTreeWitness;
+    checkMembership(root: Field, path: Field, value: Field): Bool;
+};
+declare const LinkedMerkleWitnessTemplate_base: (new (value: {
+    leaf: LinkedLeafStruct;
+    merkleWitness: RollupMerkleTreeWitness;
+}) => {
+    leaf: LinkedLeafStruct;
+    merkleWitness: RollupMerkleTreeWitness;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    leaf: LinkedLeafStruct;
+    merkleWitness: RollupMerkleTreeWitness;
+}, {
+    leaf: {
+        value: bigint;
+        path: bigint;
+        nextPath: bigint;
+    };
+    merkleWitness: {
+        path: bigint[];
+        isLeft: boolean[];
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        leaf: LinkedLeafStruct;
+        merkleWitness: RollupMerkleTreeWitness;
+    };
+} & {
+    fromValue: (value: {
+        leaf: LinkedLeafStruct | {
+            value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            nextPath: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        merkleWitness: {
+            path: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+            isLeft: import("o1js/dist/node/lib/provable/bool").Bool[] | boolean[];
+        } | RollupMerkleTreeWitness;
+    }) => {
+        leaf: LinkedLeafStruct;
+        merkleWitness: RollupMerkleTreeWitness;
+    };
+    toInput: (x: {
+        leaf: LinkedLeafStruct;
+        merkleWitness: RollupMerkleTreeWitness;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        leaf: LinkedLeafStruct;
+        merkleWitness: RollupMerkleTreeWitness;
+    }) => {
+        leaf: {
+            value: string;
+            path: string;
+            nextPath: string;
+        };
+        merkleWitness: {
+            path: string[];
+            isLeft: boolean[];
+        };
+    };
+    fromJSON: (x: {
+        leaf: {
+            value: string;
+            path: string;
+            nextPath: string;
+        };
+        merkleWitness: {
+            path: string[];
+            isLeft: boolean[];
+        };
+    }) => {
+        leaf: LinkedLeafStruct;
+        merkleWitness: RollupMerkleTreeWitness;
+    };
+    empty: () => {
+        leaf: LinkedLeafStruct;
+        merkleWitness: RollupMerkleTreeWitness;
+    };
+};
+declare class LinkedMerkleWitnessTemplate extends LinkedMerkleWitnessTemplate_base {
+    checkMembership(root: Field, path: Field, value: Field): Bool;
+}
+type LinkedOperationWitnessValue = {
+    leafPrevious: LinkedMerkleWitnessValue;
+    leafCurrent: LinkedMerkleWitnessValue;
+};
+declare const LinkedOperationWitnessTemplate_base: (new (value: {
+    leafPrevious: LinkedMerkleWitnessTemplate;
+    leafCurrent: LinkedMerkleWitnessTemplate;
+}) => {
+    leafPrevious: LinkedMerkleWitnessTemplate;
+    leafCurrent: LinkedMerkleWitnessTemplate;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    leafPrevious: LinkedMerkleWitnessTemplate;
+    leafCurrent: LinkedMerkleWitnessTemplate;
+}, {
+    leafPrevious: {
+        leaf: {
+            value: bigint;
+            path: bigint;
+            nextPath: bigint;
+        };
+        merkleWitness: {
+            path: bigint[];
+            isLeft: boolean[];
+        };
+    };
+    leafCurrent: {
+        leaf: {
+            value: bigint;
+            path: bigint;
+            nextPath: bigint;
+        };
+        merkleWitness: {
+            path: bigint[];
+            isLeft: boolean[];
+        };
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        leafPrevious: LinkedMerkleWitnessTemplate;
+        leafCurrent: LinkedMerkleWitnessTemplate;
+    };
+} & {
+    fromValue: (value: {
+        leafPrevious: LinkedMerkleWitnessTemplate | {
+            leaf: LinkedLeafStruct | {
+                value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+                path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+                nextPath: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+            merkleWitness: {
+                path: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+                isLeft: import("o1js/dist/node/lib/provable/bool").Bool[] | boolean[];
+            } | RollupMerkleTreeWitness;
+        };
+        leafCurrent: LinkedMerkleWitnessTemplate | {
+            leaf: LinkedLeafStruct | {
+                value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+                path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+                nextPath: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+            merkleWitness: {
+                path: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+                isLeft: import("o1js/dist/node/lib/provable/bool").Bool[] | boolean[];
+            } | RollupMerkleTreeWitness;
+        };
+    }) => {
+        leafPrevious: LinkedMerkleWitnessTemplate;
+        leafCurrent: LinkedMerkleWitnessTemplate;
+    };
+    toInput: (x: {
+        leafPrevious: LinkedMerkleWitnessTemplate;
+        leafCurrent: LinkedMerkleWitnessTemplate;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        leafPrevious: LinkedMerkleWitnessTemplate;
+        leafCurrent: LinkedMerkleWitnessTemplate;
+    }) => {
+        leafPrevious: {
+            leaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            merkleWitness: {
+                path: string[];
+                isLeft: boolean[];
+            };
+        };
+        leafCurrent: {
+            leaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            merkleWitness: {
+                path: string[];
+                isLeft: boolean[];
+            };
+        };
+    };
+    fromJSON: (x: {
+        leafPrevious: {
+            leaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            merkleWitness: {
+                path: string[];
+                isLeft: boolean[];
+            };
+        };
+        leafCurrent: {
+            leaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            merkleWitness: {
+                path: string[];
+                isLeft: boolean[];
+            };
+        };
+    }) => {
+        leafPrevious: LinkedMerkleWitnessTemplate;
+        leafCurrent: LinkedMerkleWitnessTemplate;
+    };
+    empty: () => {
+        leafPrevious: LinkedMerkleWitnessTemplate;
+        leafCurrent: LinkedMerkleWitnessTemplate;
+    };
+};
+declare class LinkedOperationWitnessTemplate extends LinkedOperationWitnessTemplate_base {
+}
+export interface AbstractLinkedMerkleTree {
+    leafStore: LinkedLeafStore;
+    tree: RollupMerkleTree;
+    /**
+     * Returns the root of the [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree).
+     * @returns The root of the Merkle Tree.
+     */
+    getRoot(): Field;
+    /**
+     * Sets the value of a leaf node at a given index to a given value.
+     * @param path of the leaf node.
+     * @param value New value.
+     */
+    setLeaf(path: bigint, value?: bigint): LinkedOperationWitnessValue;
+    setLeaves(batch: {
+        path: bigint;
+        value: bigint;
+    }[]): void;
+    /**
+     * Returns a leaf which lives at a given path.
+     * Errors otherwise.
+     * @param path Index of the node.
+     * @returns The data of the leaf.
+     */
+    getLeaf(path: bigint): LinkedLeafStruct | undefined;
+    /**
+     * Returns the witness (also known as
+     * [Merkle Proof or Merkle Witness](https://computersciencewiki.org/index.php/Merkle_proof))
+     * for the leaf at the given path.
+     * @param path Position of the leaf node.
+     * @returns The witness that belongs to the leaf.
+     */
+    getReadWitness(path: bigint): LinkedMerkleWitnessValue;
+}
+export interface AbstractLinkedMerkleTreeClass {
+    new (store: MerkleTreeStore, leafStore: LinkedLeafStore): AbstractLinkedMerkleTree;
+    WITNESS: typeof LinkedOperationWitnessTemplate & {
+        fromReadWitness(readWitness: LinkedMerkleWitnessTemplate): LinkedOperationWitnessTemplate;
+    };
+    READ_WITNESS: typeof LinkedMerkleWitnessTemplate & TypedClass<{
+        checkMembership(root: Field, path: Field, value: Field): Bool;
+    }>;
+    HEIGHT: number;
+    EMPTY_ROOT: Field;
+    dummyWitness(): LinkedOperationWitnessValue;
+    dummyReadWitness(): LinkedMerkleWitnessValue;
+}
+export {};
+//# sourceMappingURL=AbstractLinkedMerkleTree.d.ts.map

package/dist/trees/lmt/AbstractLinkedMerkleTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractLinkedMerkleTree.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/AbstractLinkedMerkleTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAU,MAAM,MAAM,CAAC;AAE3C,OAAO,EAAoB,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;;;;AAE3D,cAAM,uBAAwB,SAAQ,4BAA4B;CAAG;AAErE,KAAK,wBAAwB,GAAG;IAC9B,IAAI,EAAE,gBAAgB,CAAC;IACvB,aAAa,EAAE,uBAAuB,CAAC;IACvC,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC/D,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIF,cAAM,2BAA4B,SAAQ,gCAGxC;IACO,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;CAIrE;AAED,KAAK,2BAA2B,GAAG;IACjC,YAAY,EAAE,wBAAwB,CAAC;IACvC,WAAW,EAAE,wBAAwB,CAAC;CACvC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,cAAM,8BAA+B,SAAQ,mCAG3C;CAAG;AAEL,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,eAAe,CAAC;IAE3B,IAAI,EAAE,gBAAgB,CAAC;IAEvB;;;OAGG;IACH,OAAO,IAAI,KAAK,CAAC;IAEjB;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,2BAA2B,CAAC;IAEnE,SAAS,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,IAAI,CAAC;IAE1D;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAEpD;;;;;;OAMG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,wBAAwB,CAAC;CACxD;AAED,MAAM,WAAW,6BAA6B;IAC5C,KACE,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,eAAe,GACzB,wBAAwB,CAAC;IAE5B,OAAO,EAAE,OAAO,8BAA8B,GAAG;QAC/C,eAAe,CACb,WAAW,EAAE,2BAA2B,GACvC,8BAA8B,CAAC;KACnC,CAAC;IAEF,YAAY,EAAE,OAAO,2BAA2B,GAC9C,UAAU,CAAC;QACT,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;KAC/D,CAAC,CAAC;IAEL,MAAM,EAAE,MAAM,CAAC;IAEf,UAAU,EAAE,KAAK,CAAC;IAElB,YAAY,IAAI,2BAA2B,CAAC;IAE5C,gBAAgB,IAAI,wBAAwB,CAAC;CAC9C"}

package/dist/trees/lmt/AbstractLinkedMerkleTree.js

@@ -0,0 +1,22 @@
+import { Bool, Struct } from "o1js";
+import { createMerkleTree } from "../sparse/RollupMerkleTree";
+import { LinkedLeafStruct } from "./LinkedMerkleTreeTypes";
+class RollupMerkleTreeWitness extends createMerkleTree(40).WITNESS {
+}
+// We use the RollupMerkleTreeWitness here, although we will actually implement
+// the RollupMerkleTreeWitnessV2 defined below when instantiating the class.
+class LinkedMerkleWitnessTemplate extends Struct({
+    leaf: LinkedLeafStruct,
+    merkleWitness: RollupMerkleTreeWitness,
+}) {
+    checkMembership(root, path, value) {
+        // Mock implementation for typing
+        return Bool(true);
+    }
+}
+class LinkedOperationWitnessTemplate extends Struct({
+    leafPrevious: LinkedMerkleWitnessTemplate,
+    leafCurrent: LinkedMerkleWitnessTemplate,
+}) {
+}
+//# sourceMappingURL=AbstractLinkedMerkleTree.js.map

package/dist/trees/lmt/AbstractLinkedMerkleTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractLinkedMerkleTree.js","sourceRoot":"","sources":["../../../src/trees/lmt/AbstractLinkedMerkleTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAS,MAAM,EAAE,MAAM,MAAM,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAoB,MAAM,4BAA4B,CAAC;AAKhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,MAAM,uBAAwB,SAAQ,gBAAgB,CAAC,EAAE,CAAC,CAAC,OAAO;CAAG;AAQrE,+EAA+E;AAC/E,4EAA4E;AAC5E,MAAM,2BAA4B,SAAQ,MAAM,CAAC;IAC/C,IAAI,EAAE,gBAAgB;IACtB,aAAa,EAAE,uBAAuB;CACvC,CAAC;IACO,eAAe,CAAC,IAAW,EAAE,IAAW,EAAE,KAAY;QAC3D,iCAAiC;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC;CACF;AAOD,MAAM,8BAA+B,SAAQ,MAAM,CAAC;IAClD,YAAY,EAAE,2BAA2B;IACzC,WAAW,EAAE,2BAA2B;CACzC,CAAC;CAAG"}

package/dist/trees/lmt/InMemoryLinkedLeafStore.d.ts

@@ -0,0 +1,21 @@
+import { LinkedLeafStore, LinkedLeaf } from "./LinkedLeafStore";
+export declare class InMemoryLinkedLeafStore implements LinkedLeafStore {
+    leaves: {
+        [key: string]: {
+            leaf: LinkedLeaf;
+            index: bigint;
+        };
+    };
+    maximumIndex?: bigint;
+    getLeaf(path: bigint): {
+        leaf: LinkedLeaf;
+        index: bigint;
+    } | undefined;
+    setLeaf(index: bigint, value: LinkedLeaf): void;
+    getMaximumIndex(): bigint | undefined;
+    getPreviousLeaf(path: bigint): {
+        leaf: LinkedLeaf;
+        index: bigint;
+    } | undefined;
+}
+//# sourceMappingURL=InMemoryLinkedLeafStore.d.ts.map

package/dist/trees/lmt/InMemoryLinkedLeafStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLinkedLeafStore.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/InMemoryLinkedLeafStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEhE,qBAAa,uBAAwB,YAAW,eAAe;IACtD,MAAM,EAAE;QACb,CAAC,GAAG,EAAE,MAAM,GAAG;YAAE,IAAI,EAAE,UAAU,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;KACpD,CAAM;IAEA,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,OAAO,CACZ,IAAI,EAAE,MAAM,GACX;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;IAI3C,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IAa/C,eAAe,IAAI,MAAM,GAAG,SAAS;IAKrC,eAAe,CACpB,IAAI,EAAE,MAAM,GACX;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;CAMnD"}

package/dist/trees/lmt/InMemoryLinkedLeafStore.js

@@ -0,0 +1,26 @@
+export class InMemoryLinkedLeafStore {
+    constructor() {
+        this.leaves = {};
+    }
+    getLeaf(path) {
+        return this.leaves[path.toString()];
+    }
+    setLeaf(index, value) {
+        const leaf = this.getLeaf(value.path);
+        if (leaf !== undefined && leaf?.index !== index) {
+            throw new Error("Cannot change index of existing leaf");
+        }
+        this.leaves[value.path.toString()] = { leaf: value, index: index };
+        if (index > (this.maximumIndex ?? -1)) {
+            this.maximumIndex = index;
+        }
+    }
+    getMaximumIndex() {
+        return this.maximumIndex;
+    }
+    // This gets the leaf with the closest path.
+    getPreviousLeaf(path) {
+        return Object.values(this.leaves).find((storedLeaf) => storedLeaf.leaf.nextPath > path && storedLeaf.leaf.path < path);
+    }
+}
+//# sourceMappingURL=InMemoryLinkedLeafStore.js.map

package/dist/trees/lmt/InMemoryLinkedLeafStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLinkedLeafStore.js","sourceRoot":"","sources":["../../../src/trees/lmt/InMemoryLinkedLeafStore.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,uBAAuB;IAApC;QACS,WAAM,GAET,EAAE,CAAC;IAoCT,CAAC;IAhCQ,OAAO,CACZ,IAAY;QAEZ,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IACtC,CAAC;IAEM,OAAO,CAAC,KAAa,EAAE,KAAiB;QAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEtC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,EAAE,KAAK,KAAK,KAAK,EAAE;YAC/C,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;SACzD;QAED,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACnE,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,EAAE;YACrC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;SAC3B;IACH,CAAC;IAEM,eAAe;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,4CAA4C;IACrC,eAAe,CACpB,IAAY;QAEZ,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CACpC,CAAC,UAAU,EAAE,EAAE,CACb,UAAU,CAAC,IAAI,CAAC,QAAQ,GAAG,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CACjE,CAAC;IACJ,CAAC;CACF"}

package/dist/trees/lmt/InMemoryLinkedMerkleLeafStore.d.ts

@@ -0,0 +1,7 @@
+import { InMemoryLinkedLeafStore } from "./InMemoryLinkedLeafStore";
+import { InMemoryMerkleTreeStorage } from "../sparse/InMemoryMerkleTreeStorage";
+declare const InMemoryLinkedMerkleLeafStore_base: import("ts-mixer/dist/types/types").Class<any[], InMemoryLinkedLeafStore & InMemoryMerkleTreeStorage, typeof InMemoryLinkedLeafStore & typeof InMemoryMerkleTreeStorage>;
+export declare class InMemoryLinkedMerkleLeafStore extends InMemoryLinkedMerkleLeafStore_base {
+}
+export {};
+//# sourceMappingURL=InMemoryLinkedMerkleLeafStore.d.ts.map

package/dist/trees/lmt/InMemoryLinkedMerkleLeafStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLinkedMerkleLeafStore.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/InMemoryLinkedMerkleLeafStore.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;;AAEhF,qBAAa,6BAA8B,SAAQ,kCAGlD;CAAG"}

package/dist/trees/lmt/InMemoryLinkedMerkleLeafStore.js

@@ -0,0 +1,6 @@
+import { Mixin } from "ts-mixer";
+import { InMemoryLinkedLeafStore } from "./InMemoryLinkedLeafStore";
+import { InMemoryMerkleTreeStorage } from "../sparse/InMemoryMerkleTreeStorage";
+export class InMemoryLinkedMerkleLeafStore extends Mixin(InMemoryLinkedLeafStore, InMemoryMerkleTreeStorage) {
+}
+//# sourceMappingURL=InMemoryLinkedMerkleLeafStore.js.map

package/dist/trees/lmt/InMemoryLinkedMerkleLeafStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLinkedMerkleLeafStore.js","sourceRoot":"","sources":["../../../src/trees/lmt/InMemoryLinkedMerkleLeafStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAEhF,MAAM,OAAO,6BAA8B,SAAQ,KAAK,CACtD,uBAAuB,EACvB,yBAAyB,CAC1B;CAAG"}

package/dist/trees/lmt/LinkedLeafStore.d.ts

@@ -0,0 +1,16 @@
+export type LinkedLeaf = {
+    value: bigint;
+    path: bigint;
+    nextPath: bigint;
+};
+export type StoredLeaf = {
+    leaf: LinkedLeaf;
+    index: bigint;
+};
+export interface LinkedLeafStore {
+    setLeaf: (index: bigint, value: LinkedLeaf) => void;
+    getLeaf: (path: bigint) => StoredLeaf | undefined;
+    getPreviousLeaf: (path: bigint) => StoredLeaf | undefined;
+    getMaximumIndex: () => bigint | undefined;
+}
+//# sourceMappingURL=LinkedLeafStore.d.ts.map

package/dist/trees/lmt/LinkedLeafStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedLeafStore.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedLeafStore.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3E,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAEpD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;IAElD,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;IAE1D,eAAe,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC3C"}

package/dist/trees/lmt/LinkedLeafStore.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LinkedLeafStore.js.map

package/dist/trees/lmt/LinkedLeafStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedLeafStore.js","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedLeafStore.ts"],"names":[],"mappings":""}

package/dist/trees/lmt/LinkedLinkedStore.d.ts

@@ -0,0 +1,16 @@
+export type LinkedLeaf = {
+    value: bigint;
+    path: bigint;
+    nextPath: bigint;
+};
+export type StoredLeaf = {
+    leaf: LinkedLeaf;
+    index: bigint;
+};
+export interface LinkedLeafStore {
+    setLeaf: (index: bigint, value: LinkedLeaf) => void;
+    getLeaf: (path: bigint) => StoredLeaf | undefined;
+    getLeafLessOrEqual: (path: bigint) => StoredLeaf | undefined;
+    getMaximumIndex: () => bigint | undefined;
+}
+//# sourceMappingURL=LinkedLinkedStore.d.ts.map

package/dist/trees/lmt/LinkedLinkedStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedLinkedStore.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedLinkedStore.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3E,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAEpD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;IAElD,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;IAE7D,eAAe,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC3C"}

package/dist/trees/lmt/LinkedLinkedStore.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LinkedLinkedStore.js.map

package/dist/trees/lmt/LinkedLinkedStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedLinkedStore.js","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedLinkedStore.ts"],"names":[],"mappings":""}

package/dist/trees/lmt/LinkedMerkleTree.d.ts

@@ -0,0 +1,11 @@
+import { AbstractLinkedMerkleTreeClass } from "./AbstractLinkedMerkleTree";
+export declare function createLinkedMerkleTree(height: number): AbstractLinkedMerkleTreeClass;
+declare const LinkedMerkleTree_base: AbstractLinkedMerkleTreeClass;
+export declare class LinkedMerkleTree extends LinkedMerkleTree_base {
+}
+export declare class LinkedMerkleTreeWitness extends LinkedMerkleTree.WITNESS {
+}
+export declare class LinkedMerkleTreeReadWitness extends LinkedMerkleTree.READ_WITNESS {
+}
+export {};
+//# sourceMappingURL=LinkedMerkleTree.d.ts.map

package/dist/trees/lmt/LinkedMerkleTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedMerkleTree.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedMerkleTree.ts"],"names":[],"mappings":"AASA,OAAO,EAEL,6BAA6B,EAC9B,MAAM,4BAA4B,CAAC;AAapC,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,GACb,6BAA6B,CA+S/B;;AAED,qBAAa,gBAAiB,SAAQ,qBAA0B;CAAG;AACnE,qBAAa,uBAAwB,SAAQ,gBAAgB,CAAC,OAAO;CAAG;AACxE,qBAAa,2BAA4B,SAAQ,gBAAgB,CAAC,YAAY;CAAG"}