@proto-kit/protocol 0.1.1-develop.0

package/dist/model/StateTransition.d.ts

@@ -0,0 +1,135 @@
+import { Field } from "o1js";
+import { Option, ProvableOption } from "./Option";
+declare const ProvableStateTransition_base: (new (value: {
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}) => {
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}, {
+    path: bigint;
+    from: {
+        isSome: boolean;
+        value: bigint;
+    };
+    to: {
+        isSome: boolean;
+        value: bigint;
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+} & {
+    fromValue: (value: {
+        path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        to: ProvableOption | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+    }) => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+    toInput: (x: {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    }) => {
+        path: string;
+        from: {
+            isSome: boolean;
+            value: string;
+        };
+        to: {
+            isSome: boolean;
+            value: string;
+        };
+    };
+    fromJSON: (x: {
+        path: string;
+        from: {
+            isSome: boolean;
+            value: string;
+        };
+        to: {
+            isSome: boolean;
+            value: string;
+        };
+    }) => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+    empty: () => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+};
+/**
+ * Provable representation of a State Transition, used to
+ * normalize state transitions of various value types for
+ * the state transition circuit.
+ */
+export declare class ProvableStateTransition extends ProvableStateTransition_base {
+    static dummy(): ProvableStateTransition;
+}
+/**
+ * Generic state transition that constraints the current method circuit
+ * to external state, by providing a state anchor.
+ */
+export declare class StateTransition<Value> {
+    path: Field;
+    fromValue: Option<Value>;
+    toValue: Option<Field> | Option<Value>;
+    static from<Value>(path: Field, fromValue: Option<Value>): StateTransition<Value>;
+    static fromTo<Value>(path: Field, fromValue: Option<Value>, toValue: Option<Value>): StateTransition<Value>;
+    constructor(path: Field, fromValue: Option<Value>, toValue: Option<Field> | Option<Value>);
+    get from(): Option<Value>;
+    get to(): Option<import("o1js/dist/node/lib/provable/field").Field> | Option<Value>;
+    /**
+     * Converts a StateTransition to a ProvableStateTransition,
+     * while enforcing the 'from' property to be 'Some' in all cases.
+     */
+    toProvable(): ProvableStateTransition;
+    toJSON(): {
+        path: string;
+        from: {
+            isSome: boolean;
+            isForcedSome: boolean;
+            value: string[];
+        };
+        to: {
+            isSome: boolean;
+            isForcedSome: boolean;
+            value: string[];
+        };
+    };
+    toConstant(): StateTransition<Value>;
+}
+export {};
+//# sourceMappingURL=StateTransition.d.ts.map

package/dist/model/StateTransition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,MAAM,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;CAO/C;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;WAfjC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;WAIjD,MAAM,CAAC,KAAK,EACxB,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;gBAMf,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,kBAId;IAED,IAAW,EAAE,8EAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;;;IAQN,UAAU,IAAI,eAAe,CAAC,KAAK,CAAC;CAO5C"}

package/dist/model/StateTransition.js

@@ -0,0 +1,69 @@
+import { Field, Struct } from "o1js";
+import { Option, ProvableOption } from "./Option";
+/**
+ * Provable representation of a State Transition, used to
+ * normalize state transitions of various value types for
+ * the state transition circuit.
+ */
+export class ProvableStateTransition extends Struct({
+    path: Field,
+    // must be applied even if `None`
+    from: ProvableOption,
+    // must be ignored if `None`
+    to: ProvableOption,
+}) {
+    static dummy() {
+        return new ProvableStateTransition({
+            path: Field(0),
+            from: Option.none().toProvable(),
+            to: Option.none().toProvable(),
+        });
+    }
+}
+/**
+ * Generic state transition that constraints the current method circuit
+ * to external state, by providing a state anchor.
+ */
+export class StateTransition {
+    static from(path, fromValue) {
+        return new StateTransition(path, fromValue, Option.none());
+    }
+    static fromTo(path, fromValue, toValue) {
+        return new StateTransition(path, fromValue, toValue);
+    }
+    constructor(path, fromValue, toValue) {
+        this.path = path;
+        this.fromValue = fromValue;
+        this.toValue = toValue;
+    }
+    get from() {
+        const from = this.fromValue.clone();
+        from.forceSome();
+        return from;
+    }
+    get to() {
+        return this.toValue.clone();
+    }
+    /**
+     * Converts a StateTransition to a ProvableStateTransition,
+     * while enforcing the 'from' property to be 'Some' in all cases.
+     */
+    toProvable() {
+        return new ProvableStateTransition({
+            path: this.path,
+            from: this.from.toProvable(),
+            to: this.to.toProvable(),
+        });
+    }
+    toJSON() {
+        return {
+            path: this.path.toString(),
+            from: this.fromValue.toJSON(),
+            to: this.toValue.toJSON(),
+        };
+    }
+    toConstant() {
+        return new StateTransition(this.path.toConstant(), this.fromValue.toConstant(), this.toValue.toConstant());
+    }
+}
+//# sourceMappingURL=StateTransition.js.map

package/dist/model/StateTransition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransition.js","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAElD;;;;GAIG;AACH,MAAM,OAAO,uBAAwB,SAAQ,MAAM,CAAC;IAClD,IAAI,EAAE,KAAK;IAEX,iCAAiC;IACjC,IAAI,EAAE,cAAc;IAEpB,4BAA4B;IAC5B,EAAE,EAAE,cAAc;CACnB,CAAC;IACO,MAAM,CAAC,KAAK;QACjB,OAAO,IAAI,uBAAuB,CAAC;YACjC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;YACd,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE;YAChC,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE;SAC/B,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,eAAe;IACnB,MAAM,CAAC,IAAI,CAAQ,IAAW,EAAE,SAAwB;QAC7D,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IAEM,MAAM,CAAC,MAAM,CAClB,IAAW,EACX,SAAwB,EACxB,OAAsB;QAEtB,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACvD,CAAC;IAED,YACS,IAAW,EACX,SAAwB,EACxB,OAAsC;QAFtC,SAAI,GAAJ,IAAI,CAAO;QACX,cAAS,GAAT,SAAS,CAAe;QACxB,YAAO,GAAP,OAAO,CAA+B;IAC5C,CAAC;IAEJ,IAAW,IAAI;QACb,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACpC,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAW,EAAE;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACI,UAAU;QACf,OAAO,IAAI,uBAAuB,CAAC;YACjC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAC5B,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE;SACzB,CAAC,CAAC;IACL,CAAC;IAEM,MAAM;QACX,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAC1B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YAC7B,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;SAC1B,CAAC;IACJ,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,eAAe,CACxB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EACtB,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,EAC3B,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAC1B,CAAC;IACJ,CAAC;CACF"}

package/dist/model/StateTransitionProvableBatch.d.ts

@@ -0,0 +1,198 @@
+import { Bool } from "o1js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
+import { ProvableStateTransition } from "./StateTransition.js";
+export declare class StateTransitionType {
+    static readonly normal = true;
+    static readonly protocol = false;
+    static isNormal(type: boolean): boolean;
+    static isProtocol(type: boolean): boolean;
+}
+declare const ProvableStateTransitionType_base: (new (value: {
+    type: import("o1js/dist/node/lib/provable/bool").Bool;
+}) => {
+    type: import("o1js/dist/node/lib/provable/bool").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    type: import("o1js/dist/node/lib/provable/bool").Bool;
+}, {
+    type: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+} & {
+    fromValue: (value: {
+        type: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    toInput: (x: {
+        type: 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: {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        type: boolean;
+    };
+    fromJSON: (x: {
+        type: boolean;
+    }) => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    empty: () => {
+        type: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+};
+export declare class ProvableStateTransitionType extends ProvableStateTransitionType_base {
+    static get normal(): ProvableStateTransitionType;
+    static get protocol(): ProvableStateTransitionType;
+    isNormal(): Bool;
+    isProtocol(): Bool;
+}
+declare const StateTransitionProvableBatch_base: (new (value: {
+    batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
+    merkleWitnesses: RollupMerkleTreeWitness[];
+}) => {
+    batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
+    merkleWitnesses: RollupMerkleTreeWitness[];
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    batch: ProvableStateTransition[];
+    transitionTypes: ProvableStateTransitionType[];
+    merkleWitnesses: RollupMerkleTreeWitness[];
+}, {
+    batch: {
+        path: bigint;
+        from: {
+            isSome: boolean;
+            value: bigint;
+        };
+        to: {
+            isSome: boolean;
+            value: bigint;
+        };
+    }[];
+    transitionTypes: {
+        type: boolean;
+    }[];
+    merkleWitnesses: {
+        path: bigint[];
+        isLeft: boolean[];
+    }[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+        merkleWitnesses: RollupMerkleTreeWitness[];
+    };
+} & {
+    fromValue: (value: {
+        batch: ProvableStateTransition[] | {
+            path: bigint;
+            from: {
+                isSome: boolean;
+                value: bigint;
+            };
+            to: {
+                isSome: boolean;
+                value: bigint;
+            };
+        }[];
+        transitionTypes: ProvableStateTransitionType[] | {
+            type: boolean;
+        }[];
+        merkleWitnesses: RollupMerkleTreeWitness[] | {
+            path: bigint[];
+            isLeft: boolean[];
+        }[];
+    }) => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+        merkleWitnesses: RollupMerkleTreeWitness[];
+    };
+    toInput: (x: {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+        merkleWitnesses: RollupMerkleTreeWitness[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+        merkleWitnesses: RollupMerkleTreeWitness[];
+    }) => {
+        batch: {
+            path: string;
+            from: {
+                isSome: boolean;
+                value: string;
+            };
+            to: {
+                isSome: boolean;
+                value: string;
+            };
+        }[];
+        transitionTypes: {
+            type: boolean;
+        }[];
+        merkleWitnesses: {
+            path: string[];
+            isLeft: boolean[];
+        }[];
+    };
+    fromJSON: (x: {
+        batch: {
+            path: string;
+            from: {
+                isSome: boolean;
+                value: string;
+            };
+            to: {
+                isSome: boolean;
+                value: string;
+            };
+        }[];
+        transitionTypes: {
+            type: boolean;
+        }[];
+        merkleWitnesses: {
+            path: string[];
+            isLeft: boolean[];
+        }[];
+    }) => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+        merkleWitnesses: RollupMerkleTreeWitness[];
+    };
+    empty: () => {
+        batch: ProvableStateTransition[];
+        transitionTypes: ProvableStateTransitionType[];
+        merkleWitnesses: RollupMerkleTreeWitness[];
+    };
+};
+/**
+ * A Batch of StateTransitions to be consumed by the StateTransitionProver
+ * to prove multiple STs at once
+ *
+ * transitionType:
+ * true == normal ST, false == protocol ST
+ */
+export declare class StateTransitionProvableBatch extends StateTransitionProvableBatch_base {
+    static fromMappings(transitions: {
+        transition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+    }[], merkleWitnesses: RollupMerkleTreeWitness[]): StateTransitionProvableBatch;
+    static fromTransitions(transitions: ProvableStateTransition[], protocolTransitions: ProvableStateTransition[], merkleWitnesses: RollupMerkleTreeWitness[]): StateTransitionProvableBatch;
+    private constructor();
+}
+export {};
+//# sourceMappingURL=StateTransitionProvableBatch.d.ts.map

package/dist/model/StateTransitionProvableBatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,MAAM,CAAC;AAC9C,OAAO,EAIL,uBAAuB,EACxB,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,qBAAa,mBAAmB;IAC9B,gBAAuB,MAAM,QAAQ;IAErC,gBAAuB,QAAQ,SAAS;WAE1B,QAAQ,CAAC,IAAI,EAAE,OAAO;WAItB,UAAU,CAAC,IAAI,EAAE,OAAO;CAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,2BAA4B,SAAQ,gCAE/C;IACA,WAAkB,MAAM,IAAI,2BAA2B,CAItD;IAED,WAAkB,QAAQ,IAAI,2BAA2B,CAIxD;IAEM,QAAQ,IAAI,IAAI;IAIhB,UAAU,IAAI,IAAI;CAG1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;;;;;GAMG;AACH,qBAAa,4BAA6B,SAAQ,iCAehD;WACc,YAAY,CACxB,WAAW,EAAE;QACX,UAAU,EAAE,uBAAuB,CAAC;QACpC,IAAI,EAAE,2BAA2B,CAAC;KACnC,EAAE,EACH,eAAe,EAAE,uBAAuB,EAAE,GACzC,4BAA4B;WA+BjB,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,EACtC,mBAAmB,EAAE,uBAAuB,EAAE,EAC9C,eAAe,EAAE,uBAAuB,EAAE,GACzC,4BAA4B;IAuB/B,OAAO;CAOR"}

package/dist/model/StateTransitionProvableBatch.js

@@ -0,0 +1,91 @@
+import { Bool, Provable, Struct } from "o1js";
+import { InMemoryMerkleTreeStorage, range, RollupMerkleTree, RollupMerkleTreeWitness, } from "@proto-kit/common";
+import { constants } from "../Constants";
+import { ProvableStateTransition } from "./StateTransition.js";
+export class StateTransitionType {
+    static isNormal(type) {
+        return type === StateTransitionType.normal;
+    }
+    static isProtocol(type) {
+        return type === StateTransitionType.protocol;
+    }
+}
+StateTransitionType.normal = true;
+StateTransitionType.protocol = false;
+export class ProvableStateTransitionType extends Struct({
+    type: Bool,
+}) {
+    static get normal() {
+        return new ProvableStateTransitionType({
+            type: Bool(StateTransitionType.normal),
+        });
+    }
+    static get protocol() {
+        return new ProvableStateTransitionType({
+            type: Bool(StateTransitionType.protocol),
+        });
+    }
+    isNormal() {
+        return this.type;
+    }
+    isProtocol() {
+        return this.type.not();
+    }
+}
+/**
+ * A Batch of StateTransitions to be consumed by the StateTransitionProver
+ * to prove multiple STs at once
+ *
+ * transitionType:
+ * true == normal ST, false == protocol ST
+ */
+export class StateTransitionProvableBatch extends Struct({
+    batch: Provable.Array(ProvableStateTransition, constants.stateTransitionProverBatchSize),
+    transitionTypes: Provable.Array(ProvableStateTransitionType, constants.stateTransitionProverBatchSize),
+    merkleWitnesses: Provable.Array(RollupMerkleTreeWitness, constants.stateTransitionProverBatchSize),
+}) {
+    static fromMappings(transitions, merkleWitnesses) {
+        const batch = transitions.map((entry) => entry.transition);
+        const transitionTypes = transitions.map((entry) => entry.type);
+        const witnesses = merkleWitnesses.slice();
+        // Check that order is correct
+        let normalSTsStarted = false;
+        transitionTypes.forEach((x) => {
+            if (!normalSTsStarted && x.isNormal().toBoolean()) {
+                normalSTsStarted = true;
+            }
+            if (normalSTsStarted && x.isProtocol().toBoolean()) {
+                throw new Error("Order in initializing STBatch not correct");
+            }
+        });
+        while (batch.length < constants.stateTransitionProverBatchSize) {
+            batch.push(ProvableStateTransition.dummy());
+            transitionTypes.push(ProvableStateTransitionType.normal);
+            witnesses.push(new RollupMerkleTree(new InMemoryMerkleTreeStorage()).getWitness(BigInt(0)));
+        }
+        return new StateTransitionProvableBatch({
+            batch,
+            transitionTypes,
+            merkleWitnesses: witnesses,
+        });
+    }
+    static fromTransitions(transitions, protocolTransitions, merkleWitnesses) {
+        const array = transitions.slice().concat(protocolTransitions);
+        const transitionTypes = range(0, transitions.length)
+            .map(() => ProvableStateTransitionType.normal)
+            .concat(range(0, protocolTransitions.length).map(() => ProvableStateTransitionType.protocol));
+        while (array.length < constants.stateTransitionProverBatchSize) {
+            array.push(ProvableStateTransition.dummy());
+            transitionTypes.push(ProvableStateTransitionType.normal);
+        }
+        return new StateTransitionProvableBatch({
+            batch: array,
+            transitionTypes,
+            merkleWitnesses,
+        });
+    }
+    constructor(object) {
+        super(object);
+    }
+}
+//# sourceMappingURL=StateTransitionProvableBatch.js.map

package/dist/model/StateTransitionProvableBatch.js.map

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

package/dist/model/network/NetworkState.d.ts

@@ -0,0 +1,160 @@
+import { Field, UInt64 } from "o1js";
+declare const CurrentBlock_base: (new (value: {
+    height: UInt64;
+}) => {
+    height: UInt64;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    height: UInt64;
+}, {
+    height: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        height: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        height: bigint | UInt64;
+    }) => {
+        height: UInt64;
+    };
+    toInput: (x: {
+        height: UInt64;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        height: UInt64;
+    }) => {
+        height: string;
+    };
+    fromJSON: (x: {
+        height: string;
+    }) => {
+        height: UInt64;
+    };
+    empty: () => {
+        height: UInt64;
+    };
+};
+export declare class CurrentBlock extends CurrentBlock_base {
+}
+declare const PreviousBlock_base: (new (value: {
+    rootHash: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    rootHash: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    rootHash: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    rootHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        rootHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        rootHash: 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: {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        rootHash: string;
+    };
+    fromJSON: (x: {
+        rootHash: string;
+    }) => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        rootHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class PreviousBlock extends PreviousBlock_base {
+}
+declare const NetworkState_base: (new (value: {
+    block: CurrentBlock;
+    previous: PreviousBlock;
+}) => {
+    block: CurrentBlock;
+    previous: PreviousBlock;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    block: CurrentBlock;
+    previous: PreviousBlock;
+}, {
+    block: {
+        height: bigint;
+    };
+    previous: {
+        rootHash: bigint;
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    };
+} & {
+    fromValue: (value: {
+        block: CurrentBlock | {
+            height: bigint | UInt64;
+        };
+        previous: PreviousBlock | {
+            rootHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+    }) => {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    };
+    toInput: (x: {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    }) => {
+        block: {
+            height: string;
+        };
+        previous: {
+            rootHash: string;
+        };
+    };
+    fromJSON: (x: {
+        block: {
+            height: string;
+        };
+        previous: {
+            rootHash: string;
+        };
+    }) => {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    };
+    empty: () => {
+        block: CurrentBlock;
+        previous: PreviousBlock;
+    };
+};
+export declare class NetworkState extends NetworkState_base {
+    hash(): Field;
+    static empty(): NetworkState;
+}
+export {};
+//# sourceMappingURL=NetworkState.d.ts.map

package/dist/model/network/NetworkState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkState.d.ts","sourceRoot":"","sources":["../../../src/model/network/NetworkState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,EAAE,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvD,qBAAa,YAAa,SAAQ,iBAEhC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,aAAc,SAAQ,kBAEjC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,YAAa,SAAQ,iBAGhC;IACO,IAAI,IAAI,KAAK;WAON,KAAK;CAUpB"}