@proto-kit/common 0.1.1-develop.1665 → 0.1.1-develop.1688

package/dist/dependencyFactory/injectOptional.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This function injects a dependency only if it has been registered, otherwise
+ * injects undefined. This can be useful for having optional dependencies, where
+ * tsyringe would normally error out and not be able to resolve. With this
+ * decorator, we can now do this.
+ *
+ * The strategy we employ here is that we inject a dummy into the global
+ * container that is of type UndefinedDisguise. We can't inject undefined
+ * directly, therefore we use this object to disguise itself as undefined.
+ * Then a child container registers something under the same token, it by
+ * default resolves that new dependency. If that doesn't happen, the
+ * resolution hits our disguise, which we then convert into undefined
+ * using the Transform
+ */
+export declare function injectOptional<T>(token: string): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;
+//# sourceMappingURL=injectOptional.d.ts.map

package/dist/dependencyFactory/injectOptional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectOptional.d.ts","sourceRoot":"","sources":["../../src/dependencyFactory/injectOptional.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,0FAG9C"}

package/dist/dependencyFactory/injectOptional.js

@@ -0,0 +1,40 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { container, injectable, injectWithTransform, Lifecycle, scoped, } from "tsyringe";
+let UndefinedDisguise = class UndefinedDisguise {
+};
+UndefinedDisguise = __decorate([
+    injectable(),
+    scoped(Lifecycle.ResolutionScoped)
+], UndefinedDisguise);
+class UndefinedTransform {
+    transform(incoming) {
+        if (incoming instanceof UndefinedDisguise) {
+            return undefined;
+        }
+        return incoming;
+    }
+}
+/**
+ * This function injects a dependency only if it has been registered, otherwise
+ * injects undefined. This can be useful for having optional dependencies, where
+ * tsyringe would normally error out and not be able to resolve. With this
+ * decorator, we can now do this.
+ *
+ * The strategy we employ here is that we inject a dummy into the global
+ * container that is of type UndefinedDisguise. We can't inject undefined
+ * directly, therefore we use this object to disguise itself as undefined.
+ * Then a child container registers something under the same token, it by
+ * default resolves that new dependency. If that doesn't happen, the
+ * resolution hits our disguise, which we then convert into undefined
+ * using the Transform
+ */
+export function injectOptional(token) {
+    container.register(token, { useClass: UndefinedDisguise });
+    return injectWithTransform(token, (UndefinedTransform));
+}
+//# sourceMappingURL=injectOptional.js.map

package/dist/dependencyFactory/injectOptional.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectOptional.js","sourceRoot":"","sources":["../../src/dependencyFactory/injectOptional.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EACL,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,SAAS,EACT,MAAM,GACP,MAAM,UAAU,CAAC;AAIlB,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;CAAG,CAAA;AAApB,iBAAiB;IAFtB,UAAU,EAAE;IACZ,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC;GAC7B,iBAAiB,CAAG;AAE1B,MAAM,kBAAkB;IACf,SAAS,CACd,QAAwC;QAExC,IAAI,QAAQ,YAAY,iBAAiB,EAAE;YACzC,OAAO,SAAS,CAAC;SAClB;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAAI,KAAa;IAC7C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC3D,OAAO,mBAAmB,CAAC,KAAK,EAAE,CAAA,kBAAqB,CAAA,CAAC,CAAC;AAC3D,CAAC"}

package/dist/trees/InMemoryLinkedLeafStore.d.ts

@@ -0,0 +1,21 @@
+import { LinkedLeafStore, LinkedLeaf } from "./LinkedMerkleTreeStore";
+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;
+    getLeafLessOrEqual(path: bigint): {
+        leaf: LinkedLeaf;
+        index: bigint;
+    } | undefined;
+}
+//# sourceMappingURL=InMemoryLinkedLeafStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLinkedLeafStore.d.ts","sourceRoot":"","sources":["../../src/trees/InMemoryLinkedLeafStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAEtE,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;IAW/C,eAAe,IAAI,MAAM,GAAG,SAAS;IAKrC,kBAAkB,CACvB,IAAI,EAAE,MAAM,GACX;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS;CAMnD"}

package/dist/trees/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 (this.maximumIndex === undefined || index > this.maximumIndex) {
+            this.maximumIndex = index;
+        }
+    }
+    getMaximumIndex() {
+        return this.maximumIndex;
+    }
+    // This gets the leaf with the closest path.
+    getLeafLessOrEqual(path) {
+        return Object.values(this.leaves).find((storedLeaf) => storedLeaf.leaf.nextPath > path && storedLeaf.leaf.path <= path);
+    }
+}
+//# sourceMappingURL=InMemoryLinkedLeafStore.js.map

package/dist/trees/InMemoryLinkedLeafStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLinkedLeafStore.js","sourceRoot":"","sources":["../../src/trees/InMemoryLinkedLeafStore.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,uBAAuB;IAApC;QACS,WAAM,GAET,EAAE,CAAC;IAkCT,CAAC;IA9BQ,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;QACtC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,EAAE,KAAK,KAAK,KAAK,EAAE;YAC/C,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;SACzD;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACnE,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE;YAChE,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;SAC3B;IACH,CAAC;IAEM,eAAe;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,4CAA4C;IACrC,kBAAkB,CACvB,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,IAAI,IAAI,CAClE,CAAC;IACJ,CAAC;CACF"}

package/dist/trees/InMemoryLinkedMerkleLeafStore.d.ts

@@ -0,0 +1,7 @@
+import { InMemoryLinkedLeafStore } from "./InMemoryLinkedLeafStore";
+import { InMemoryMerkleTreeStorage } from "./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/InMemoryLinkedMerkleLeafStore.d.ts.map

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

package/dist/trees/InMemoryLinkedMerkleLeafStore.js

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

package/dist/trees/InMemoryLinkedMerkleLeafStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryLinkedMerkleLeafStore.js","sourceRoot":"","sources":["../../src/trees/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,6BAA6B,CAAC;AAExE,MAAM,OAAO,6BAA8B,SAAQ,KAAK,CACtD,uBAAuB,EACvB,yBAAyB,CAC1B;CAAG"}

package/dist/trees/InMemoryMerkleTreeStorage.d.ts

@@ -0,0 +1,11 @@
+import { MerkleTreeStore } from "./MerkleTreeStore";
+export declare class InMemoryMerkleTreeStorage implements MerkleTreeStore {
+    protected nodes: {
+        [key: number]: {
+            [key: string]: bigint;
+        };
+    };
+    getNode(key: bigint, level: number): bigint | undefined;
+    setNode(key: bigint, level: number, value: bigint): void;
+}
+//# sourceMappingURL=InMemoryMerkleTreeStorage.d.ts.map

package/dist/trees/InMemoryMerkleTreeStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryMerkleTreeStorage.d.ts","sourceRoot":"","sources":["../../src/trees/InMemoryMerkleTreeStorage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,yBAA0B,YAAW,eAAe;IAC/D,SAAS,CAAC,KAAK,EAAE;QACf,CAAC,GAAG,EAAE,MAAM,GAAG;YACb,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;SACvB,CAAC;KACH,CAAM;IAEA,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIvD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAGhE"}

package/dist/trees/InMemoryMerkleTreeStorage.js

@@ -0,0 +1,13 @@
+export class InMemoryMerkleTreeStorage {
+    constructor() {
+        this.nodes = {};
+    }
+    getNode(key, level) {
+        return this.nodes[level]?.[key.toString()];
+    }
+    setNode(key, level, value) {
+        var _a;
+        ((_a = this.nodes)[level] ?? (_a[level] = {}))[key.toString()] = value;
+    }
+}
+//# sourceMappingURL=InMemoryMerkleTreeStorage.js.map

package/dist/trees/InMemoryMerkleTreeStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryMerkleTreeStorage.js","sourceRoot":"","sources":["../../src/trees/InMemoryMerkleTreeStorage.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,yBAAyB;IAAtC;QACY,UAAK,GAIX,EAAE,CAAC;IAST,CAAC;IAPQ,OAAO,CAAC,GAAW,EAAE,KAAa;QACvC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC7C,CAAC;IAEM,OAAO,CAAC,GAAW,EAAE,KAAa,EAAE,KAAa;;QACtD,OAAC,IAAI,CAAC,KAAK,EAAC,KAAK,SAAL,KAAK,IAAM,EAAE,EAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,KAAK,CAAC;IACrD,CAAC;CACF"}

package/dist/trees/LinkedMerkleTree.d.ts

@@ -0,0 +1,345 @@
+import { Field } from "o1js";
+import { TypedClass } from "../types";
+import { LinkedMerkleTreeStore } from "./LinkedMerkleTreeStore";
+import { AbstractMerkleWitness } from "./RollupMerkleTree";
+declare const LinkedLeafStruct_base: (new (value: {
+    value: import("o1js/dist/node/lib/provable/field").Field;
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    nextPath: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    value: import("o1js/dist/node/lib/provable/field").Field;
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    nextPath: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    value: import("o1js/dist/node/lib/provable/field").Field;
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    nextPath: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    value: bigint;
+    path: bigint;
+    nextPath: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        value: import("o1js/dist/node/lib/provable/field").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        nextPath: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        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;
+    }) => {
+        value: import("o1js/dist/node/lib/provable/field").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        nextPath: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        value: import("o1js/dist/node/lib/provable/field").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        nextPath: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        value: import("o1js/dist/node/lib/provable/field").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        nextPath: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        value: string;
+        path: string;
+        nextPath: string;
+    };
+    fromJSON: (x: {
+        value: string;
+        path: string;
+        nextPath: string;
+    }) => {
+        value: import("o1js/dist/node/lib/provable/field").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        nextPath: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        value: import("o1js/dist/node/lib/provable/field").Field;
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        nextPath: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class LinkedLeafStruct extends LinkedLeafStruct_base {
+    hash(): Field;
+}
+declare const LinkedLeafAndMerkleWitness_base: (new (value: {
+    leaf: LinkedLeafStruct;
+    merkleWitness: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+}) => {
+    leaf: LinkedLeafStruct;
+    merkleWitness: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    leaf: LinkedLeafStruct;
+    merkleWitness: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+}, {
+    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: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+    };
+} & {
+    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[];
+        } | (AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate);
+    }) => {
+        leaf: LinkedLeafStruct;
+        merkleWitness: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+    };
+    toInput: (x: {
+        leaf: LinkedLeafStruct;
+        merkleWitness: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+    }) => {
+        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: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+    }) => {
+        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: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+    };
+    empty: () => {
+        leaf: LinkedLeafStruct;
+        merkleWitness: AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate;
+    };
+};
+export declare class LinkedLeafAndMerkleWitness extends LinkedLeafAndMerkleWitness_base {
+}
+declare const LinkedStructTemplate_base: (new (value: {
+    leafPrevious: LinkedLeafAndMerkleWitness;
+    leafCurrent: LinkedLeafAndMerkleWitness;
+}) => {
+    leafPrevious: LinkedLeafAndMerkleWitness;
+    leafCurrent: LinkedLeafAndMerkleWitness;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    leafPrevious: LinkedLeafAndMerkleWitness;
+    leafCurrent: LinkedLeafAndMerkleWitness;
+}, {
+    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: LinkedLeafAndMerkleWitness;
+        leafCurrent: LinkedLeafAndMerkleWitness;
+    };
+} & {
+    fromValue: (value: {
+        leafPrevious: LinkedLeafAndMerkleWitness | {
+            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[];
+            } | (AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate);
+        };
+        leafCurrent: LinkedLeafAndMerkleWitness | {
+            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[];
+            } | (AbstractMerkleWitness & import("./RollupMerkleTree").StructTemplate);
+        };
+    }) => {
+        leafPrevious: LinkedLeafAndMerkleWitness;
+        leafCurrent: LinkedLeafAndMerkleWitness;
+    };
+    toInput: (x: {
+        leafPrevious: LinkedLeafAndMerkleWitness;
+        leafCurrent: LinkedLeafAndMerkleWitness;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        leafPrevious: LinkedLeafAndMerkleWitness;
+        leafCurrent: LinkedLeafAndMerkleWitness;
+    }) => {
+        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: LinkedLeafAndMerkleWitness;
+        leafCurrent: LinkedLeafAndMerkleWitness;
+    };
+    empty: () => {
+        leafPrevious: LinkedLeafAndMerkleWitness;
+        leafCurrent: LinkedLeafAndMerkleWitness;
+    };
+};
+declare class LinkedStructTemplate extends LinkedStructTemplate_base {
+}
+export interface AbstractLinkedMerkleWitness extends LinkedStructTemplate {
+}
+export interface AbstractLinkedMerkleTree {
+    store: LinkedMerkleTreeStore;
+    /**
+     * Returns a node which lives at a given index and level.
+     * @param level Level of the node.
+     * @param index Index of the node.
+     * @returns The data of the node.
+     */
+    getNode(level: number, index: bigint): Field;
+    /**
+     * 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): LinkedMerkleTreeWitness;
+    /**
+     * 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.
+     */
+    getWitness(path: bigint): LinkedLeafAndMerkleWitness;
+    dummyWitness(): LinkedMerkleTreeWitness;
+    dummy(): LinkedLeafAndMerkleWitness;
+}
+export interface AbstractLinkedMerkleTreeClass {
+    new (store: LinkedMerkleTreeStore): AbstractLinkedMerkleTree;
+    WITNESS: TypedClass<AbstractLinkedMerkleWitness> & typeof LinkedStructTemplate;
+    HEIGHT: number;
+    EMPTY_ROOT: bigint;
+}
+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 {};
+//# sourceMappingURL=LinkedMerkleTree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedMerkleTree.d.ts","sourceRoot":"","sources":["../../src/trees/LinkedMerkleTree.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,EAA8B,MAAM,MAAM,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGtC,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EACL,qBAAqB,EAGtB,MAAM,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI5B,qBAAa,gBAAiB,SAAQ,qBAIpC;IACO,IAAI,IAAI,KAAK;CAGrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAID,qBAAa,0BAA2B,SAAQ,+BAG9C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,cAAM,oBAAqB,SAAQ,yBAGjC;CAAG;AAEL,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB;CAAG;AAE5E,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,qBAAqB,CAAC;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;IAE7C;;;OAGG;IACH,OAAO,IAAI,KAAK,CAAC;IAEjB;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,uBAAuB,CAAC;IAE/D;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;IAEpD;;;;;;OAMG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,0BAA0B,CAAC;IAErD,YAAY,IAAI,uBAAuB,CAAC;IAExC,KAAK,IAAI,0BAA0B,CAAC;CACrC;AAED,MAAM,WAAW,6BAA6B;IAC5C,KAAK,KAAK,EAAE,qBAAqB,GAAG,wBAAwB,CAAC;IAE7D,OAAO,EAAE,UAAU,CAAC,2BAA2B,CAAC,GAC9C,OAAO,oBAAoB,CAAC;IAE9B,MAAM,EAAE,MAAM,CAAC;IAEf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,GACb,6BAA6B,CAyX/B;;AAED,qBAAa,gBAAiB,SAAQ,qBAA0B;CAAG;AACnE,qBAAa,uBAAwB,SAAQ,gBAAgB,CAAC,OAAO;CAAG"}