@proto-kit/common 0.1.1-develop.211 → 0.1.1-develop.2137

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"}

package/dist/trees/lmt/LinkedMerkleTree.js

@@ -0,0 +1,241 @@
+import { Field, Struct } from "o1js";
+import { createMerkleTree } from "../sparse/RollupMerkleTree";
+import { InMemoryMerkleTreeStorage } from "../sparse/InMemoryMerkleTreeStorage";
+import { InMemoryLinkedLeafStore } from "./InMemoryLinkedLeafStore";
+import { LinkedLeafStruct } from "./LinkedMerkleTreeTypes";
+export function createLinkedMerkleTree(height) {
+    var _a;
+    const SparseTreeClass = createMerkleTree(height);
+    class LinkedLeafAndMerkleWitness extends Struct({
+        leaf: LinkedLeafStruct,
+        merkleWitness: SparseTreeClass.WITNESS,
+    }) {
+        checkMembership(root, path, value) {
+            const pathEquals = path.equals(this.leaf.path);
+            return this.merkleWitness
+                .calculateRoot(new LinkedLeafStruct({
+                ...this.leaf,
+                value,
+            }).hash())
+                .equals(root)
+                .and(pathEquals);
+        }
+    }
+    class LinkedOperationWitness extends Struct({
+        leafPrevious: LinkedLeafAndMerkleWitness,
+        leafCurrent: LinkedLeafAndMerkleWitness,
+    }) {
+        // implements LinkedStructTemplate
+        static fromReadWitness(readWitness) {
+            return new LinkedOperationWitness({
+                leafPrevious: new LinkedLeafAndMerkleWitness({
+                    merkleWitness: SparseTreeClass.WITNESS.dummy(),
+                    leaf: LinkedLeafStruct.dummy(),
+                }),
+                leafCurrent: readWitness,
+            });
+        }
+    }
+    return _a = class AbstractLinkedRollupMerkleTree {
+            constructor(store, leafStore) {
+                this.leafStore = leafStore;
+                this.tree = new SparseTreeClass(store);
+                // We only do the leaf initialisation when the store
+                // has no values. Otherwise, we leave the store
+                // as is to not overwrite any data.
+                if (this.leafStore.getLeaf(0n) === undefined) {
+                    this.setLeafInitialisation();
+                }
+            }
+            /**
+             * Returns leaf which lives at a given path.
+             * Errors if the path is not defined.
+             * @param path path of the node.
+             * @returns The data of the node.
+             */
+            getLeaf(path) {
+                const storedLeaf = this.leafStore.getLeaf(path);
+                if (storedLeaf === undefined) {
+                    return undefined;
+                }
+                return new LinkedLeafStruct({
+                    value: Field(storedLeaf.leaf.value),
+                    path: Field(storedLeaf.leaf.path),
+                    nextPath: Field(storedLeaf.leaf.nextPath),
+                });
+            }
+            /**
+             * Returns the root of the [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree).
+             * @returns The root of the Merkle Tree.
+             */
+            getRoot() {
+                return this.tree.getRoot().toConstant();
+            }
+            writeLeaf(index, leaf) {
+                this.leafStore.setLeaf(index, leaf);
+                const leafHash = new LinkedLeafStruct(LinkedLeafStruct.fromValue(leaf)).hash();
+                return {
+                    index,
+                    leaf: leafHash,
+                };
+            }
+            setLeafInternal(path, value) {
+                const storedLeaf = this.leafStore.getLeaf(path);
+                if (storedLeaf === undefined) {
+                    // Insert case
+                    // The above means the path doesn't already exist, and we are inserting, not updating.
+                    // This requires us to update the node with the previous path, as well.
+                    const tempIndex = this.leafStore.getMaximumIndex();
+                    if (tempIndex === undefined) {
+                        throw Error("Store Max Index not defined");
+                    }
+                    if (tempIndex + 1n >= 2 ** height) {
+                        throw new Error("Index greater than maximum leaf number");
+                    }
+                    const nextFreeIndex = tempIndex + 1n;
+                    const previousLeaf = this.leafStore.getPreviousLeaf(path);
+                    if (previousLeaf === undefined) {
+                        throw Error(`Prev leaf shouldn't be undefined (path ${path})`);
+                    }
+                    const newPrevLeaf = {
+                        ...previousLeaf.leaf,
+                        nextPath: path,
+                    };
+                    const treeWrite1 = this.writeLeaf(previousLeaf.index, newPrevLeaf);
+                    const newLeaf = {
+                        path,
+                        value,
+                        nextPath: previousLeaf.leaf.nextPath,
+                    };
+                    const treeWrite2 = this.writeLeaf(nextFreeIndex, newLeaf);
+                    return {
+                        leafPrevious: {
+                            witness: previousLeaf.index,
+                            witnessLeaf: new LinkedLeafStruct(LinkedLeafStruct.fromValue(previousLeaf.leaf)),
+                            write: treeWrite1,
+                        },
+                        leafCurrent: {
+                            witness: nextFreeIndex,
+                            witnessLeaf: LinkedLeafStruct.dummy(),
+                            write: treeWrite2,
+                        },
+                    };
+                }
+                else {
+                    // Update case
+                    const updatedLeaf = {
+                        ...storedLeaf.leaf,
+                        value: value,
+                    };
+                    const treeWrite = this.writeLeaf(storedLeaf.index, updatedLeaf);
+                    return {
+                        leafPrevious: "dummy",
+                        leafCurrent: {
+                            witness: storedLeaf.index,
+                            witnessLeaf: new LinkedLeafStruct(LinkedLeafStruct.fromValue(storedLeaf.leaf)),
+                            write: treeWrite,
+                        },
+                    };
+                }
+            }
+            applyOperationInstruction(instruction) {
+                if (instruction === "dummy") {
+                    return AbstractLinkedRollupMerkleTree.dummyReadWitness();
+                }
+                const merkleWitness = this.tree.getWitness(instruction.witness);
+                this.tree.setLeaf(instruction.write.index, instruction.write.leaf);
+                return new LinkedLeafAndMerkleWitness({
+                    merkleWitness,
+                    leaf: instruction.witnessLeaf,
+                });
+            }
+            /**
+             * Sets the value of a node at a given index to a given value.
+             * @param path Position of the leaf node.
+             * @param value New value.
+             */
+            setLeaf(path, value) {
+                const { leafPrevious: previousLeafInstruction, leafCurrent: currentLeafInstruction, } = this.setLeafInternal(path, value);
+                const leafPrevious = this.applyOperationInstruction(previousLeafInstruction);
+                const leafCurrent = this.applyOperationInstruction(currentLeafInstruction);
+                return { leafPrevious, leafCurrent };
+            }
+            setLeaves(batch) {
+                if (batch.length > 0) {
+                    const witnesses = batch.map(({ path, value }) => this.setLeafInternal(path, value));
+                    // tree.setLeafBatch internally takes care of making the writes unique to optimize
+                    this.tree.setLeaves(witnesses.flatMap(({ leafPrevious, leafCurrent }) => (leafPrevious === "dummy" ? [] : [leafPrevious.write]).concat(leafCurrent.write)));
+                }
+            }
+            /**
+             * Sets the value of a leaf node at initialisation,
+             * i.e.  {vale: 0, path: 0, nextPath: Field.Max}
+             */
+            setLeafInitialisation() {
+                // This is the maximum value of the hash
+                const MAX_FIELD_VALUE = Field.ORDER - 1n;
+                const zeroLeaf = {
+                    value: 0n,
+                    path: 0n,
+                    nextPath: MAX_FIELD_VALUE,
+                };
+                this.leafStore.setLeaf(0n, zeroLeaf);
+                // We now set the leafs in the merkle tree to cascade the values up
+                // the tree.
+                this.tree.setLeaf(0n, new LinkedLeafStruct(LinkedLeafStruct.fromValue(zeroLeaf)).hash());
+            }
+            /**
+             * 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, otherwise returns a witness for the first unused index.
+             * @param path of the leaf node.
+             * @returns The witness that belongs to the leaf.
+             */
+            getReadWitness(path) {
+                const storedLeaf = this.leafStore.getLeaf(path);
+                let leaf;
+                let currentIndex;
+                if (storedLeaf === undefined) {
+                    const storeIndex = this.leafStore.getMaximumIndex();
+                    if (storeIndex === undefined) {
+                        throw new Error("Store undefined");
+                    }
+                    currentIndex = storeIndex + 1n;
+                    leaf = LinkedLeafStruct.dummy();
+                }
+                else {
+                    leaf = new LinkedLeafStruct(LinkedLeafStruct.fromValue(storedLeaf.leaf));
+                    currentIndex = storedLeaf.index;
+                }
+                const merkleWitness = this.tree.getWitness(currentIndex);
+                return new LinkedLeafAndMerkleWitness({
+                    merkleWitness,
+                    leaf,
+                });
+            }
+            static dummyReadWitness() {
+                return new LinkedLeafAndMerkleWitness({
+                    merkleWitness: SparseTreeClass.WITNESS.dummy(),
+                    leaf: LinkedLeafStruct.dummy(),
+                });
+            }
+            static dummyWitness() {
+                return new LinkedOperationWitness({
+                    leafPrevious: AbstractLinkedRollupMerkleTree.dummyReadWitness(),
+                    leafCurrent: AbstractLinkedRollupMerkleTree.dummyReadWitness(),
+                });
+            }
+        },
+        _a.HEIGHT = height,
+        _a.EMPTY_ROOT = new _a(new InMemoryMerkleTreeStorage(), new InMemoryLinkedLeafStore()).getRoot(),
+        _a.READ_WITNESS = LinkedLeafAndMerkleWitness,
+        _a.WITNESS = LinkedOperationWitness,
+        _a;
+}
+export class LinkedMerkleTree extends createLinkedMerkleTree(40) {
+}
+export class LinkedMerkleTreeWitness extends LinkedMerkleTree.WITNESS {
+}
+export class LinkedMerkleTreeReadWitness extends LinkedMerkleTree.READ_WITNESS {
+}
+//# sourceMappingURL=LinkedMerkleTree.js.map

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

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

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

@@ -0,0 +1,113 @@
+import { Field } from "o1js";
+import { LinkedMerkleTreeWitness } from "./LinkedMerkleTree";
+import { LinkedLeafStruct } from "./LinkedMerkleTreeTypes";
+export type TreeWrite = {
+    path: Field;
+    from: Field;
+    to: Field;
+};
+export declare namespace LinkedMerkleTreeCircuitOps {
+    const ComputeRootInstruction_base: (new (value: {
+        newPreviousLeaf: LinkedLeafStruct;
+        newCurrentLeaf: LinkedLeafStruct;
+        allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        newPreviousLeaf: LinkedLeafStruct;
+        newCurrentLeaf: LinkedLeafStruct;
+        allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) & {
+        _isStruct: true;
+    } & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+        newPreviousLeaf: LinkedLeafStruct;
+        newCurrentLeaf: LinkedLeafStruct;
+        allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+    }, {
+        newPreviousLeaf: {
+            value: bigint;
+            path: bigint;
+            nextPath: bigint;
+        };
+        newCurrentLeaf: {
+            value: bigint;
+            path: bigint;
+            nextPath: bigint;
+        };
+        allChecksMet: boolean;
+    }>, "fromFields"> & {
+        fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+            newPreviousLeaf: LinkedLeafStruct;
+            newCurrentLeaf: LinkedLeafStruct;
+            allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+        };
+    } & {
+        fromValue: (value: {
+            newPreviousLeaf: 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;
+            };
+            newCurrentLeaf: 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;
+            };
+            allChecksMet: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        }) => {
+            newPreviousLeaf: LinkedLeafStruct;
+            newCurrentLeaf: LinkedLeafStruct;
+            allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+        };
+        toInput: (x: {
+            newPreviousLeaf: LinkedLeafStruct;
+            newCurrentLeaf: LinkedLeafStruct;
+            allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+        }) => {
+            fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+            packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+        };
+        toJSON: (x: {
+            newPreviousLeaf: LinkedLeafStruct;
+            newCurrentLeaf: LinkedLeafStruct;
+            allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+        }) => {
+            newPreviousLeaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            newCurrentLeaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            allChecksMet: boolean;
+        };
+        fromJSON: (x: {
+            newPreviousLeaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            newCurrentLeaf: {
+                value: string;
+                path: string;
+                nextPath: string;
+            };
+            allChecksMet: boolean;
+        }) => {
+            newPreviousLeaf: LinkedLeafStruct;
+            newCurrentLeaf: LinkedLeafStruct;
+            allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+        };
+        empty: () => {
+            newPreviousLeaf: LinkedLeafStruct;
+            newCurrentLeaf: LinkedLeafStruct;
+            allChecksMet: import("o1js/dist/node/lib/provable/bool").Bool;
+        };
+    };
+    export class ComputeRootInstruction extends ComputeRootInstruction_base {
+    }
+    export function applyTreeWrite(root: Field, witness: LinkedMerkleTreeWitness, treeWrite: TreeWrite, index: number): Field;
+    export {};
+}
+//# sourceMappingURL=LinkedMerkleTreeCircuitOps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedMerkleTreeCircuitOps.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedMerkleTreeCircuitOps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,EAAoB,MAAM,MAAM,CAAC;AAErD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAK3D,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,KAAK,CAAC;IACZ,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,KAAK,CAAC;CACX,CAAC;AAEF,yBAAiB,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAU1C,MAAM,OAAO,sBAAuB,SAAQ,2BAI1C;KAAG;IA2HL,MAAM,UAAU,cAAc,CAC5B,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,uBAAuB,EAChC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,GACZ,KAAK,CA4BP;;CACF"}

package/dist/trees/lmt/LinkedMerkleTreeCircuitOps.js

@@ -0,0 +1,113 @@
+import { Bool, Field, Provable, Struct } from "o1js";
+import { LinkedLeafStruct } from "./LinkedMerkleTreeTypes";
+export var LinkedMerkleTreeCircuitOps;
+(function (LinkedMerkleTreeCircuitOps) {
+    function boolAllTrue(...args) {
+        return args.reduce((a, b, i) => {
+            // if (!b.toBoolean()) {
+            //   console.log();
+            // }
+            return a.and(b);
+        });
+    }
+    class ComputeRootInstruction extends Struct({
+        newPreviousLeaf: LinkedLeafStruct,
+        newCurrentLeaf: LinkedLeafStruct,
+        allChecksMet: Bool,
+    }) {
+    }
+    LinkedMerkleTreeCircuitOps.ComputeRootInstruction = ComputeRootInstruction;
+    function chooseInstruction(isUpdate, updateInstruction, insertInstruction) {
+        return Provable.if(isUpdate, ComputeRootInstruction, updateInstruction, insertInstruction);
+    }
+    /**
+     * verifyWitness(current.merkleWitness, current.leaf)
+     *
+     * st.path == current.leaf.path
+     * st.from.value == current.leaf.value
+     * ```
+     *
+     * updates:
+     * ```
+     * current := { current.path, current.nextPath, value: st.to.value }
+     */
+    function update({ leafCurrent, leafPrevious }, { to, from, path }) {
+        const allChecksMet = boolAllTrue(path.equals(leafCurrent.leaf.path), leafCurrent.leaf.value.equals(from));
+        return {
+            newPreviousLeaf: leafPrevious.leaf,
+            newCurrentLeaf: new LinkedLeafStruct({
+                ...leafCurrent.leaf,
+                value: to,
+            }),
+            allChecksMet,
+        };
+    }
+    /**
+     * st.path == current.leaf.path
+     *
+     * previous.leaf.nextPath > current.leaf.path
+     * previous.leaf.path < current.leaf.path
+     * previous.leaf.nextPath == current.leaf.nextPath
+     *
+     * index(current.merkleWitness) == nextFreeIndex
+     *
+     * updates:
+     * previous := { previous.path, previous.value, nextPath: current.path }
+     * current := current.leaf
+     */
+    function insert(witness, { path, to }) {
+        const { leafPrevious: previous, leafCurrent: current } = witness;
+        const allChecksMet = boolAllTrue(
+        // Already covered in general checks
+        // path.equals(current.leaf.path),
+        current.leaf.isDummy(), previous.leaf.nextPath.greaterThan(path), previous.leaf.path.lessThan(path));
+        return {
+            newPreviousLeaf: new LinkedLeafStruct({
+                ...previous.leaf,
+                nextPath: path,
+            }),
+            newCurrentLeaf: new LinkedLeafStruct({
+                path,
+                value: to,
+                nextPath: previous.leaf.nextPath,
+            }),
+            allChecksMet,
+        };
+    }
+    function computeRoot(witness, newPreviousLeaf, newCurrentLeaf, isUpdate, isDummy, root) {
+        const { leafPrevious, leafCurrent } = witness;
+        leafPrevious.merkleWitness
+            .calculateRoot(leafPrevious.leaf.hash())
+            .equals(root)
+            .or(isUpdate)
+            .assertTrue("Previous leaf calculation not matching");
+        const root1 = leafPrevious.merkleWitness.calculateRoot(newPreviousLeaf.hash());
+        const intermediateRoot = Provable.if(isUpdate, root, root1);
+        // TODO Make this Provable.if more efficient
+        const leafCurrentLeaf = Provable.if(isUpdate, leafCurrent.leaf.hash(), Field(0));
+        leafCurrent.merkleWitness
+            .calculateRoot(leafCurrentLeaf)
+            .equals(intermediateRoot)
+            .or(isDummy)
+            .assertTrue("Current leaf witness invalid");
+        return leafCurrent.merkleWitness.calculateRoot(newCurrentLeaf.hash());
+    }
+    function applyTreeWrite(root, witness, treeWrite, index) {
+        const { leafPrevious, leafCurrent } = witness;
+        const isUpdate = leafPrevious.leaf.isDummy();
+        const isDummy = leafCurrent.leaf.isDummy().and(isUpdate);
+        // For read-only and update
+        const updateState = update(witness, treeWrite);
+        // For insert
+        const insertState = insert(witness, treeWrite);
+        const instruction = chooseInstruction(isUpdate, updateState, insertState);
+        instruction.allChecksMet
+            .or(isDummy)
+            .assertTrue(`Not all witness checks have been met: ${index}`);
+        const newRoot = computeRoot(witness, instruction.newPreviousLeaf, instruction.newCurrentLeaf, isUpdate, isDummy, root);
+        return Provable.if(isDummy, root, newRoot);
+    }
+    LinkedMerkleTreeCircuitOps.applyTreeWrite = applyTreeWrite;
+})(LinkedMerkleTreeCircuitOps || (LinkedMerkleTreeCircuitOps = {}));
+/* eslint-enable no-inner-declarations */
+//# sourceMappingURL=LinkedMerkleTreeCircuitOps.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { MerkleTreeStore } from "../sparse/MerkleTreeStore";
+import { LinkedLeafStore } from "./LinkedLinkedStore";
+export interface SyncLinkedMerkleTreeDatabase {
+    treeStore: MerkleTreeStore;
+    leafStore: LinkedLeafStore;
+}
+//# sourceMappingURL=LinkedMerkleTreeDatabase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedMerkleTreeDatabase.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedMerkleTreeDatabase.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,eAAe,CAAC;CAC5B"}

package/dist/trees/lmt/LinkedMerkleTreeDatabase.js

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

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

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

package/dist/trees/lmt/LinkedMerkleTreeStore.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=LinkedMerkleTreeStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedMerkleTreeStore.d.ts","sourceRoot":"","sources":["../../../src/trees/lmt/LinkedMerkleTreeStore.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/LinkedMerkleTreeStore.js

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

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

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