@proto-kit/protocol 0.1.1-develop.600 → 0.1.1-develop.833

package/dist/state/protocol/ProtocolState.js

@@ -11,12 +11,10 @@ const errors = {
  */
 export function protocolState() {
     return (target, propertyKey) => {
-        // eslint-disable-next-line @typescript-eslint/init-declarations
         let value;
         Object.defineProperty(target, propertyKey, {
             enumerable: true,
             get: function get() {
-                // eslint-disable-next-line max-len
                 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 const self = this;
                 if (self.name === undefined) {
@@ -25,7 +23,6 @@ export function protocolState() {
                 if (!self.protocol) {
                     throw errors.missingProtocol(self.constructor.name);
                 }
-                // eslint-disable-next-line no-warning-comments
                 // TODO Add Prefix?
                 const path = Path.fromProperty(self.name, propertyKey);
                 if (value) {

package/dist/utils/AppliedBatchHashList.d.ts

@@ -0,0 +1,17 @@
+import { Bool, Field } from "o1js";
+import { AppliedStateTransitionBatch } from "../model/StateTransitionProvableBatch";
+import { DefaultProvableHashList } from "./ProvableHashList";
+/**
+ * A HashList for AppliedSTBatches, that in addition to the default
+ * functionality, checks that the pushed batches are not empty.
+ * If they are, the pushing is skipped.
+ * Note that if the batch has applied: false, the batch still has to be appended
+ * if it has STs inside
+ */
+export declare class AppliedBatchHashList extends DefaultProvableHashList<AppliedStateTransitionBatch> {
+    constructor(commitment: Field);
+    private isNotEmpty;
+    push(value: AppliedStateTransitionBatch): this;
+    pushIf(value: AppliedStateTransitionBatch, condition: Bool): this;
+}
+//# sourceMappingURL=AppliedBatchHashList.d.ts.map

package/dist/utils/AppliedBatchHashList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppliedBatchHashList.d.ts","sourceRoot":"","sources":["../../src/utils/AppliedBatchHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;;;;;GAMG;AACH,qBAAa,oBAAqB,SAAQ,uBAAuB,CAAC,2BAA2B,CAAC;gBACzE,UAAU,EAAE,KAAK;IAIpC,OAAO,CAAC,UAAU;IAIX,IAAI,CAAC,KAAK,EAAE,2BAA2B;IAIvC,MAAM,CAAC,KAAK,EAAE,2BAA2B,EAAE,SAAS,EAAE,IAAI;CAGlE"}

package/dist/utils/AppliedBatchHashList.js

@@ -0,0 +1,24 @@
+import { Field } from "o1js";
+import { AppliedStateTransitionBatch } from "../model/StateTransitionProvableBatch";
+import { DefaultProvableHashList } from "./ProvableHashList";
+/**
+ * A HashList for AppliedSTBatches, that in addition to the default
+ * functionality, checks that the pushed batches are not empty.
+ * If they are, the pushing is skipped.
+ * Note that if the batch has applied: false, the batch still has to be appended
+ * if it has STs inside
+ */
+export class AppliedBatchHashList extends DefaultProvableHashList {
+    constructor(commitment) {
+        super(AppliedStateTransitionBatch, commitment);
+    }
+    isNotEmpty(value) {
+        return value.batchHash.equals(Field(0)).not();
+    }
+    push(value) {
+        return super.pushIf(value, this.isNotEmpty(value));
+    }
+    pushIf(value, condition) {
+        return super.pushIf(value, condition.and(this.isNotEmpty(value)));
+    }
+}

package/dist/utils/MinaPrefixedProvableHashList.d.ts

@@ -1,4 +1,4 @@
-import { Field, FlexibleProvablePure } from "o1js";
+import { Field, ProvablePure } from "o1js";
 import { ProvableHashList } from "./ProvableHashList";
 export declare const MINA_EVENT_PREFIXES: {
     readonly event: "MinaZkappEvent******";
@@ -15,7 +15,7 @@ export declare class MinaEvents {
 }
 export declare class MinaPrefixedProvableHashList<Value> extends ProvableHashList<Value> {
     readonly prefix: string;
-    constructor(valueType: FlexibleProvablePure<Value>, prefix: string, internalCommitment?: Field);
+    constructor(valueType: ProvablePure<Value>, prefix: string, internalCommitment?: Field);
     protected hash(elements: Field[]): Field;
 }
 export declare class MinaActionsHashList extends MinaPrefixedProvableHashList<Field> {

package/dist/utils/MinaPrefixedProvableHashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MinaPrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/MinaPrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAY,MAAM,MAAM,CAAC;AAG7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAStD,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wBAAgB,WAAW,IAAI,KAAK,CAEnC;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,GAAE,KAAsB,GACnC,KAAK;CAOT;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,KAAqB,GAAG,KAAK;CAO7E;AAED,qBAAa,4BAA4B,CACvC,KAAK,CACL,SAAQ,gBAAgB,CAAC,KAAK,CAAC;aAGb,MAAM,EAAE,MAAM;gBAD9B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACtB,MAAM,EAAE,MAAM,EAC9B,kBAAkB,GAAE,KAAgB;IAKtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAKzC;AAED,qBAAa,mBAAoB,SAAQ,4BAA4B,CAAC,KAAK,CAAC;gBACvD,kBAAkB,GAAE,KAAgB;CAGxD"}
+{"version":3,"file":"MinaPrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/MinaPrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,YAAY,EAAE,MAAM,MAAM,CAAC;AAGrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAUtD,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,wBAAgB,YAAY,IAAI,KAAK,CAEpC;AAED,wBAAgB,WAAW,IAAI,KAAK,CAEnC;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,GAAE,KAAsB,GACnC,KAAK;CAOT;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,YAAY,GAAE,KAAqB,GAAG,KAAK;CAO7E;AAED,qBAAa,4BAA4B,CACvC,KAAK,CACL,SAAQ,gBAAgB,CAAC,KAAK,CAAC;aAGb,MAAM,EAAE,MAAM;gBAD9B,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EACd,MAAM,EAAE,MAAM,EAC9B,kBAAkB,GAAE,KAAgB;IAKtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAKzC;AAED,qBAAa,mBAAoB,SAAQ,4BAA4B,CAAC,KAAK,CAAC;gBACvD,kBAAkB,GAAE,KAAgB;CAGxD"}

package/dist/utils/MinaPrefixedProvableHashList.js

@@ -2,6 +2,7 @@ import { Field, Poseidon } from "o1js";
 import { hashWithPrefix, prefixToField } from "@proto-kit/common";
 import { ProvableHashList } from "./ProvableHashList";
 function salt(prefix) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return Poseidon.update([Field(0), Field(0), Field(0)], [prefixToField(prefix)]);
 }
 export const MINA_EVENT_PREFIXES = {

package/dist/utils/PrefixedProvableHashList.d.ts

@@ -1,8 +1,8 @@
-import { Field, FlexibleProvablePure } from "o1js";
+import { Field, ProvablePure } from "o1js";
 import { ProvableHashList } from "./ProvableHashList.js";
 export declare class PrefixedProvableHashList<Value> extends ProvableHashList<Value> {
     private readonly prefix;
-    constructor(valueType: FlexibleProvablePure<Value>, prefix: string, internalCommitment?: Field);
+    constructor(valueType: ProvablePure<Value>, prefix: string, internalCommitment?: Field);
     protected hash(elements: Field[]): Field;
 }
 //# sourceMappingURL=PrefixedProvableHashList.d.ts.map

package/dist/utils/PrefixedProvableHashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/PrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAY,MAAM,MAAM,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,qBAAa,wBAAwB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAG7B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EACtC,MAAM,EAAE,MAAM,EACd,kBAAkB,GAAE,KAAgB;IAMtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGzC"}
+{"version":3,"file":"PrefixedProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/PrefixedProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAY,MAAM,MAAM,CAAC;AAErD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,qBAAa,wBAAwB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAC1E,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;gBAG7B,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EAC9B,MAAM,EAAE,MAAM,EACd,kBAAkB,GAAE,KAAgB;IAMtC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGzC"}

package/dist/utils/ProvableHashList.d.ts

@@ -1,11 +1,11 @@
-import { Field, FlexibleProvablePure, Bool } from "o1js";
+import { Field, Bool, ProvablePure } from "o1js";
 /**
  * Utilities for creating a hash list from a given value type.
  */
 export declare abstract class ProvableHashList<Value> {
-    private readonly valueType;
+    protected readonly valueType: ProvablePure<Value>;
     commitment: Field;
-    constructor(valueType: FlexibleProvablePure<Value>, commitment?: Field);
+    constructor(valueType: ProvablePure<Value>, commitment?: Field);
     protected abstract hash(elements: Field[]): Field;
     /**
      * Converts the provided value to Field[] and appends it to
@@ -19,7 +19,7 @@ export declare abstract class ProvableHashList<Value> {
     /**
      * @returns Traling hash of the current hashlist.
      */
-    toField(): import("o1js/dist/node/lib/field").Field;
+    toField(): import("o1js/dist/node/lib/provable/field").Field;
 }
 export declare class DefaultProvableHashList<Value> extends ProvableHashList<Value> {
     hash(elements: Field[]): Field;

package/dist/utils/ProvableHashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/ProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,oBAAoB,EAAE,IAAI,EAAY,MAAM,MAAM,CAAC;AAE7E;;GAEG;AACH,8BAAsB,gBAAgB,CAAC,KAAK;IAExC,OAAO,CAAC,QAAQ,CAAC,SAAS;IACnB,UAAU,EAAE,KAAK;gBADP,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAChD,UAAU,GAAE,KAAgB;IAGrC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;IAEjD;;;;;;OAMG;IACI,IAAI,CAAC,KAAK,EAAE,KAAK;IAQjB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI;IAS3C;;OAEG;IACI,OAAO;CAGf;AAED,qBAAa,uBAAuB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAClE,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGtC"}
+{"version":3,"file":"ProvableHashList.d.ts","sourceRoot":"","sources":["../../src/utils/ProvableHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAY,IAAI,EAAY,YAAY,EAAE,MAAM,MAAM,CAAC;AAErE;;GAEG;AACH,8BAAsB,gBAAgB,CAAC,KAAK;IAExC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC;IAC1C,UAAU,EAAE,KAAK;gBADL,SAAS,EAAE,YAAY,CAAC,KAAK,CAAC,EAC1C,UAAU,GAAE,KAAgB;IAGrC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;IAEjD;;;;;;OAMG;IACI,IAAI,CAAC,KAAK,EAAE,KAAK;IAQjB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI;IAS3C;;OAEG;IACI,OAAO;CAGf;AAED,qBAAa,uBAAuB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAClE,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGtC"}

package/dist/utils/ProvableReductionHashList.d.ts

@@ -0,0 +1,14 @@
+import { Bool, Field } from "o1js";
+import { ProvableHashList } from "./ProvableHashList";
+export declare class ProvableReductionHashList<Value> extends ProvableHashList<Value> {
+    unconstrainedList: Value[];
+    private constrainedLastValue;
+    private preimage;
+    pushAndReduce(value: Value, reduce: (previous: Value) => [Value, Bool]): {
+        popLast: Bool;
+        value: Value;
+    };
+    pushIf(value: Value, condition: Bool): this;
+    hash(elements: Field[]): Field;
+}
+//# sourceMappingURL=ProvableReductionHashList.d.ts.map

package/dist/utils/ProvableReductionHashList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableReductionHashList.d.ts","sourceRoot":"","sources":["../../src/utils/ProvableReductionHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAsB,MAAM,MAAM,CAAC;AAEvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,yBAAyB,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IACpE,iBAAiB,EAAE,KAAK,EAAE,CAAM;IAEvC,OAAO,CAAC,oBAAoB,CAAgC;IAE5D,OAAO,CAAC,QAAQ,CAA0B;IAEnC,aAAa,CAClB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,GACzC;QAAE,OAAO,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE;IA4C3B,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI;IAMpC,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,KAAK;CAGtC"}

package/dist/utils/ProvableReductionHashList.js

@@ -0,0 +1,50 @@
+import { Bool, Poseidon, Provable } from "o1js";
+import { ProvableHashList } from "./ProvableHashList";
+export class ProvableReductionHashList extends ProvableHashList {
+    constructor() {
+        super(...arguments);
+        this.unconstrainedList = [];
+        this.constrainedLastValue = undefined;
+        this.preimage = this.commitment;
+    }
+    pushAndReduce(value, reduce) {
+        let valueToPush = value;
+        let popLast = Bool(false);
+        // Theoretically, we can feed the preimage + last value as a witness
+        // for non-zero commitment starts (like used in the BlockProver), because
+        // currently it won't reduce across chunks. But this is okay for now I think
+        if (this.constrainedLastValue !== undefined) {
+            [valueToPush, popLast] = reduce(this.constrainedLastValue);
+        }
+        Provable.asProver(() => {
+            if (popLast.toBoolean()) {
+                this.unconstrainedList.pop();
+            }
+            const valueAsConstant = this.valueType.fromFields(this.valueType.toFields(valueToPush).map((field) => field.toConstant()));
+            this.unconstrainedList.push(valueAsConstant);
+        });
+        const currentCommitment = this.commitment;
+        const noPopCommitment = this.hash([
+            currentCommitment,
+            ...this.valueType.toFields(valueToPush),
+        ]);
+        const popCommitment = this.hash([
+            this.preimage,
+            ...this.valueType.toFields(valueToPush),
+        ]);
+        this.commitment = Provable.if(popLast, popCommitment, noPopCommitment);
+        this.constrainedLastValue = valueToPush;
+        this.preimage = Provable.if(popLast, this.preimage, currentCommitment);
+        return {
+            popLast,
+            value: valueToPush,
+        };
+    }
+    pushIf(value, condition) {
+        throw new Error("pushIf is not implemented for ReducedHashList");
+        return this;
+    }
+    hash(elements) {
+        return Poseidon.hash(elements);
+    }
+}

package/dist/utils/StateTransitionReductionList.d.ts

@@ -0,0 +1,11 @@
+import { ProvableStateTransition, StateTransition } from "../model/StateTransition";
+import { ProvableReductionHashList } from "./ProvableReductionHashList";
+export declare class StateTransitionReductionList extends ProvableReductionHashList<ProvableStateTransition> {
+    push(value: ProvableStateTransition): this;
+    pushWithMetadata(value: ProvableStateTransition): {
+        popLast: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: ProvableStateTransition;
+    };
+}
+export declare function reduceStateTransitions(transitions: StateTransition<unknown>[]): StateTransition<unknown>[];
+//# sourceMappingURL=StateTransitionReductionList.d.ts.map

package/dist/utils/StateTransitionReductionList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionReductionList.d.ts","sourceRoot":"","sources":["../../src/utils/StateTransitionReductionList.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,uBAAuB,EACvB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,qBAAa,4BAA6B,SAAQ,yBAAyB,CAAC,uBAAuB,CAAC;IAC3F,IAAI,CAAC,KAAK,EAAE,uBAAuB;IAMnC,gBAAgB,CAAC,KAAK,EAAE,uBAAuB;;;;CAyCvD;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}

package/dist/utils/StateTransitionReductionList.js

@@ -0,0 +1,60 @@
+import { Provable } from "o1js";
+import { ProvableOption } from "../model/Option";
+import { ProvableStateTransition, StateTransition, } from "../model/StateTransition";
+import { ProvableReductionHashList } from "./ProvableReductionHashList";
+export class StateTransitionReductionList extends ProvableReductionHashList {
+    push(value) {
+        this.pushWithMetadata(value);
+        return this;
+    }
+    pushWithMetadata(value) {
+        return this.pushAndReduce(value, (previous) => {
+            const pathsMatch = previous.path.equals(value.path);
+            // Take the previous.from if the paths match, otherwise leave ST as is
+            const from = Provable.if(pathsMatch, ProvableOption, previous.from, value.from);
+            // In case we have a layout like
+            // { from: 5, to: 10 }, { from: 10, to: none }
+            // we just take the first and discard the second
+            const to = Provable.if(value.to.isSome.or(pathsMatch.not()), ProvableOption, value.to, previous.to);
+            const transition = new ProvableStateTransition({
+                path: value.path,
+                from: new ProvableOption(from),
+                to: new ProvableOption(to),
+            });
+            // Assert that connection is correct
+            previous.to.value
+                .equals(value.from.value)
+                .or(previous.to.isSome
+                .not()
+                .and(previous.from.value.equals(value.from.value)))
+                .or(pathsMatch.not())
+                .assertTrue();
+            return [transition, pathsMatch];
+        });
+    }
+}
+export function reduceStateTransitions(transitions) {
+    const reduced = [];
+    transitions.forEach((st) => {
+        if (reduced.length === 0) {
+            reduced.push(st);
+            return;
+        }
+        const last = reduced.at(-1);
+        if (last.path.equals(st.path).toBoolean()) {
+            if (st.toValue.isSome.toBoolean()) {
+                reduced.pop();
+                reduced.push(new StateTransition(st.path, last.fromValue, st.toValue));
+            }
+            else {
+                // Do nothing, because we discard that ST
+                // { from: 5, to: 10 }, { from: 10, to: none }
+                // cancel the 2nd
+            }
+        }
+        else {
+            reduced.push(st);
+        }
+    });
+    return reduced;
+}

package/dist/utils/merkletree/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/utils/merkletree/InMemoryMerkleTreeStorage.d.ts.map

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

@@ -0,0 +1,12 @@
+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;
+    }
+}

package/dist/utils/merkletree/MerkleTreeStore.d.ts

@@ -0,0 +1,5 @@
+export interface MerkleTreeStore {
+    setNode: (key: bigint, level: number, value: bigint) => void;
+    getNode: (key: bigint, level: number) => bigint | undefined;
+}
+//# sourceMappingURL=MerkleTreeStore.d.ts.map

package/dist/utils/merkletree/MerkleTreeStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MerkleTreeStore.d.ts","sourceRoot":"","sources":["../../../src/utils/merkletree/MerkleTreeStore.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE7D,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC7D"}

package/dist/utils/merkletree/MerkleTreeStore.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/merkletree/RollupMerkleTree.d.ts

@@ -0,0 +1,133 @@
+import { Bool, Field } from "o1js";
+import { MerkleTreeStore } from "./MerkleTreeStore";
+export { RollupMerkleTree, RollupMerkleWitness };
+export { maybeSwap };
+declare const RollupMerkleWitness_base: (new (value: {
+    path: import("o1js/dist/node/lib/field").Field[];
+    isLeft: import("o1js/dist/node/lib/bool").Bool[];
+}) => {
+    path: import("o1js/dist/node/lib/field").Field[];
+    isLeft: import("o1js/dist/node/lib/bool").Bool[];
+}) & {
+    _isStruct: true;
+} & import("o1js/dist/node/snarky").ProvablePure<{
+    path: import("o1js/dist/node/lib/field").Field[];
+    isLeft: import("o1js/dist/node/lib/bool").Bool[];
+}> & {
+    toInput: (x: {
+        path: import("o1js/dist/node/lib/field").Field[];
+        isLeft: import("o1js/dist/node/lib/bool").Bool[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        path: import("o1js/dist/node/lib/field").Field[];
+        isLeft: import("o1js/dist/node/lib/bool").Bool[];
+    }) => {
+        path: string[];
+        isLeft: boolean[];
+    };
+    fromJSON: (x: {
+        path: string[];
+        isLeft: boolean[];
+    }) => {
+        path: import("o1js/dist/node/lib/field").Field[];
+        isLeft: import("o1js/dist/node/lib/bool").Bool[];
+    };
+};
+/**
+ * The {@link BaseMerkleWitness} class defines a circuit-compatible base class
+ * for [Merkle Witness'](https://computersciencewiki.org/index.php/Merkle_proof).
+ */
+declare class RollupMerkleWitness extends RollupMerkleWitness_base {
+    static height: number;
+    height(): number;
+    /**
+     * Calculates a root depending on the leaf value.
+     * @param leaf Value of the leaf node that belongs to this Witness.
+     * @returns The calculated root.
+     */
+    calculateRoot(hash: Field): Field;
+    /**
+     * Calculates the index of the leaf node that belongs to this Witness.
+     * @returns Index of the leaf.
+     */
+    calculateIndex(): Field;
+    toShortenedEntries(): string[];
+}
+/**
+ * A [Merkle Tree](https://en.wikipedia.org/wiki/Merkle_tree) is a binary tree in
+ * which every leaf is the cryptography hash of a piece of data,
+ * and every node is the hash of the concatenation of its two child nodes.
+ *
+ * A Merkle Tree allows developers to easily and securely verify
+ * the integrity of large amounts of data.
+ *
+ * Take a look at our [documentation](https://docs.minaprotocol.com/en/zkapps)
+ * on how to use Merkle Trees in combination with zkApps and
+ * zero knowledge programming!
+ *
+ * Levels are indexed from leaves (level 0) to root (level N - 1).
+ */
+declare class RollupMerkleTree {
+    static height: number;
+    static EMPTY_ROOT: bigint;
+    static get leafCount(): bigint;
+    private readonly zeroes;
+    readonly store: MerkleTreeStore;
+    constructor(store: MerkleTreeStore);
+    /**
+     * 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;
+    private setNode;
+    /**
+     * TODO: if this is passed an index bigger than the max, it will set a couple
+     * of out-of-bounds nodes but not affect the real Merkle root. OK?
+     */
+    /**
+     * Sets the value of a leaf node at a given index to a given value.
+     * @param index Position of the leaf node.
+     * @param leaf New value.
+     */
+    setLeaf(index: bigint, leaf: Field): void;
+    /**
+     * Returns the witness (also known as
+     * [Merkle Proof or Merkle Witness](https://computersciencewiki.org/index.php/Merkle_proof))
+     * for the leaf at the given index.
+     * @param index Position of the leaf node.
+     * @returns The witness that belongs to the leaf.
+     */
+    getWitness(index: bigint): RollupMerkleWitness;
+    /**
+     * Fills all leaves of the tree.
+     * @param leaves Values to fill the leaves with.
+     */
+    fill(leaves: Field[]): void;
+    /**
+     * Returns the amount of leaf nodes.
+     * @returns Amount of leaf nodes.
+     */
+    get leafCount(): bigint;
+}
+export declare namespace MerkleTreeUtils {
+    function normalizeKey(key: Field): Field;
+    function checkMembership(witness: RollupMerkleWitness, root: Field, key: Field, value: Field): Bool;
+    function checkMembershipGetRoots(witness: RollupMerkleWitness, root: Field, key: Field, value: Field): [Bool, Field, Field];
+    function computeRoot(witness: RollupMerkleWitness, value: Field): Field;
+}
+/**
+ * More efficient version of `maybeSwapBad` which
+ * reuses an intermediate variable
+ */
+declare function maybeSwap(b: Bool, x: Field, y: Field): [Field, Field];
+//# sourceMappingURL=RollupMerkleTree.d.ts.map

package/dist/utils/merkletree/RollupMerkleTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RollupMerkleTree.d.ts","sourceRoot":"","sources":["../../../src/utils/merkletree/RollupMerkleTree.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,IAAI,EAAE,KAAK,EAA8B,MAAM,MAAM,CAAC;AAK/D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAKpD,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,CAAC;AAIjD,OAAO,EAAE,SAAS,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErB;;;GAGG;AACH,cAAM,mBAAoB,SAAQ,wBAGhC;IACA,OAAc,MAAM,SAAO;IAEpB,MAAM,IAAI,MAAM;IAIvB;;;;OAIG;IACI,aAAa,CAAC,IAAI,EAAE,KAAK,GAAG,KAAK;IAaxC;;;OAGG;IACI,cAAc,IAAI,KAAK;IAkBvB,kBAAkB;CAO1B;AAED;;;;;;;;;;;;;GAaG;AACH,cAAM,gBAAgB;IACpB,OAAc,MAAM,SAAO;IAE3B,OAAc,UAAU,SAIV;IAEd,WAAkB,SAAS,IAAI,MAAM,CAEpC;IAED,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAElC,SAAgB,KAAK,EAAE,eAAe,CAAC;gBAEpB,KAAK,EAAE,eAAe;IAYzC;;;;;OAKG;IAEI,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK;IAInD;;;OAGG;IAEI,OAAO,IAAI,KAAK;IAMvB,OAAO,CAAC,OAAO;IAIf;;;OAGG;IAEH;;;;OAIG;IAEI,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK;IAgBzC;;;;;;OAMG;IACI,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB;IAqBrD;;;OAGG;IAEI,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE;IAM3B;;;OAGG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;CACF;AAGD,yBAAiB,eAAe,CAAC;IAC/B,SAAgB,YAAY,CAAC,GAAG,EAAE,KAAK,GAAG,KAAK,CAS9C;IAED,SAAgB,eAAe,CAC7B,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,KAAK,EACV,KAAK,EAAE,KAAK,GACX,IAAI,CAKN;IAED,SAAgB,uBAAuB,CACrC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,KAAK,EACV,KAAK,EAAE,KAAK,GACX,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAKtB;IAED,SAAgB,WAAW,CACzB,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,KAAK,GACX,KAAK,CAEP;CACF;AAED;;;GAGG;AACH,iBAAS,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAK9D"}