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

package/dist/model/StateTransitionProvableBatch.d.ts

@@ -1,67 +1,268 @@
-import { Bool } from "snarkyjs";
+import { Bool } from "o1js";
+import { LinkedMerkleTreeWitness } 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;
+    static readonly nothing = 2;
+    static readonly closeAndApply = 1;
+    static readonly closeAndThrowAway = 0;
 }
 declare const ProvableStateTransitionType_base: (new (value: {
-    type: import("snarkyjs/dist/node/lib/bool").Bool;
+    type: import("o1js/dist/node/lib/provable/field").Field;
 }) => {
-    type: import("snarkyjs/dist/node/lib/bool").Bool;
+    type: import("o1js/dist/node/lib/provable/field").Field;
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky").ProvablePure<{
-    type: import("snarkyjs/dist/node/lib/bool").Bool;
-}> & {
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    type: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    type: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        type: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        type: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        type: import("o1js/dist/node/lib/provable/field").Field;
+    };
     toInput: (x: {
-        type: import("snarkyjs/dist/node/lib/bool").Bool;
+        type: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+        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("snarkyjs/dist/node/lib/bool").Bool;
+        type: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        type: boolean;
+        type: string;
     };
     fromJSON: (x: {
-        type: boolean;
+        type: string;
     }) => {
-        type: import("snarkyjs/dist/node/lib/bool").Bool;
+        type: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        type: import("o1js/dist/node/lib/provable/field").Field;
     };
 };
+/**
+ * STType is encoding both the type and whether it should be accumulated or not in one field
+ */
 export declare class ProvableStateTransitionType extends ProvableStateTransitionType_base {
-    static get normal(): ProvableStateTransitionType;
-    static get protocol(): ProvableStateTransitionType;
-    isNormal(): Bool;
-    isProtocol(): Bool;
+    static get nothing(): ProvableStateTransitionType;
+    static get closeAndApply(): ProvableStateTransitionType;
+    static get closeAndThrowAway(): ProvableStateTransitionType;
+    private static from;
+    isClosing(): import("o1js/dist/node/lib/provable/bool").Bool;
+    isNothing(): import("o1js/dist/node/lib/provable/bool").Bool;
 }
-declare const StateTransitionProvableBatch_base: (new (value: {
-    batch: ProvableStateTransition[];
-    transitionTypes: ProvableStateTransitionType[];
+declare const MerkleWitnessBatch_base: (new (value: {
+    witnesses: LinkedMerkleTreeWitness[];
 }) => {
-    batch: ProvableStateTransition[];
-    transitionTypes: ProvableStateTransitionType[];
+    witnesses: LinkedMerkleTreeWitness[];
 }) & {
     _isStruct: true;
-} & import("snarkyjs/dist/node/snarky").ProvablePure<{
-    batch: ProvableStateTransition[];
-    transitionTypes: ProvableStateTransitionType[];
-}> & {
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    witnesses: LinkedMerkleTreeWitness[];
+}, {
+    witnesses: {
+        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[]) => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
+} & {
+    fromValue: (value: {
+        witnesses: LinkedMerkleTreeWitness[] | {
+            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[];
+                };
+            };
+        }[];
+    }) => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
     toInput: (x: {
-        batch: ProvableStateTransition[];
-        transitionTypes: ProvableStateTransitionType[];
+        witnesses: LinkedMerkleTreeWitness[];
     }) => {
-        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
-        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+        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[];
+        witnesses: LinkedMerkleTreeWitness[];
     }) => {
-        batch: {
+        witnesses: {
+            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: {
+        witnesses: {
+            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[];
+                };
+            };
+        }[];
+    }) => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
+    empty: () => {
+        witnesses: LinkedMerkleTreeWitness[];
+    };
+};
+export declare class MerkleWitnessBatch extends MerkleWitnessBatch_base {
+}
+declare const ProvableStateTransitionEntry_base: (new (value: {
+    stateTransition: ProvableStateTransition;
+    type: ProvableStateTransitionType;
+    witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+}) => {
+    stateTransition: ProvableStateTransition;
+    type: ProvableStateTransitionType;
+    witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    stateTransition: ProvableStateTransition;
+    type: ProvableStateTransitionType;
+    witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+}, {
+    stateTransition: {
+        path: bigint;
+        from: {
+            isSome: boolean;
+            value: bigint;
+        };
+        to: {
+            isSome: boolean;
+            value: bigint;
+        };
+    };
+    type: {
+        type: bigint;
+    };
+    witnessRoot: boolean;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+} & {
+    fromValue: (value: {
+        stateTransition: ProvableStateTransition | {
+            path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            from: import("./Option").ProvableOption | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+            to: import("./Option").ProvableOption | {
+                isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+                value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            };
+        };
+        type: ProvableStateTransitionType | {
+            type: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        witnessRoot: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    toInput: (x: {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: 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: {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    }) => {
+        stateTransition: {
             path: string;
             from: {
                 isSome: boolean;
@@ -71,13 +272,14 @@ declare const StateTransitionProvableBatch_base: (new (value: {
                 isSome: boolean;
                 value: string;
             };
-        }[];
-        transitionTypes: {
-            type: boolean;
-        }[];
+        };
+        type: {
+            type: string;
+        };
+        witnessRoot: boolean;
     };
     fromJSON: (x: {
-        batch: {
+        stateTransition: {
             path: string;
             from: {
                 isSome: boolean;
@@ -87,29 +289,142 @@ declare const StateTransitionProvableBatch_base: (new (value: {
                 isSome: boolean;
                 value: string;
             };
+        };
+        type: {
+            type: string;
+        };
+        witnessRoot: boolean;
+    }) => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+    empty: () => {
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
+    };
+};
+export declare class ProvableStateTransitionEntry extends ProvableStateTransitionEntry_base {
+    static dummy(): ProvableStateTransitionEntry;
+}
+declare const StateTransitionProvableBatch_base: (new (value: {
+    batch: ProvableStateTransitionEntry[];
+}) => {
+    batch: ProvableStateTransitionEntry[];
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    batch: ProvableStateTransitionEntry[];
+}, {
+    batch: {
+        stateTransition: {
+            path: bigint;
+            from: {
+                isSome: boolean;
+                value: bigint;
+            };
+            to: {
+                isSome: boolean;
+                value: bigint;
+            };
+        };
+        type: {
+            type: bigint;
+        };
+        witnessRoot: boolean;
+    }[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        batch: ProvableStateTransitionEntry[];
+    };
+} & {
+    fromValue: (value: {
+        batch: ProvableStateTransitionEntry[] | {
+            stateTransition: {
+                path: bigint;
+                from: {
+                    isSome: boolean;
+                    value: bigint;
+                };
+                to: {
+                    isSome: boolean;
+                    value: bigint;
+                };
+            };
+            type: {
+                type: bigint;
+            };
+            witnessRoot: boolean;
+        }[];
+    }) => {
+        batch: ProvableStateTransitionEntry[];
+    };
+    toInput: (x: {
+        batch: ProvableStateTransitionEntry[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        batch: ProvableStateTransitionEntry[];
+    }) => {
+        batch: {
+            stateTransition: {
+                path: string;
+                from: {
+                    isSome: boolean;
+                    value: string;
+                };
+                to: {
+                    isSome: boolean;
+                    value: string;
+                };
+            };
+            type: {
+                type: string;
+            };
+            witnessRoot: boolean;
         }[];
-        transitionTypes: {
-            type: boolean;
+    };
+    fromJSON: (x: {
+        batch: {
+            stateTransition: {
+                path: string;
+                from: {
+                    isSome: boolean;
+                    value: string;
+                };
+                to: {
+                    isSome: boolean;
+                    value: string;
+                };
+            };
+            type: {
+                type: string;
+            };
+            witnessRoot: boolean;
         }[];
     }) => {
-        batch: ProvableStateTransition[];
-        transitionTypes: ProvableStateTransitionType[];
+        batch: ProvableStateTransitionEntry[];
+    };
+    empty: () => {
+        batch: ProvableStateTransitionEntry[];
     };
 };
 /**
  * A Batch of StateTransitions to be consumed by the StateTransitionProver
  * to prove multiple STs at once
  *
- * transitionType:
- * true == normal ST, false == protocol ST
+ * The batch is formed as an array fo ProvableSTEntries, which have a type and
+ * witnessesRoot flag attached to them.
  */
 export declare class StateTransitionProvableBatch extends StateTransitionProvableBatch_base {
-    static fromMappings(transitions: {
-        transition: ProvableStateTransition;
-        type: ProvableStateTransitionType;
-    }[]): StateTransitionProvableBatch;
-    static fromTransitions(transitions: ProvableStateTransition[], protocolTransitions: ProvableStateTransition[]): StateTransitionProvableBatch;
-    private constructor();
+    static fromBatches(batches: {
+        stateTransitions: ProvableStateTransition[];
+        applied: Bool;
+        witnessRoot: Bool;
+    }[]): StateTransitionProvableBatch[];
 }
 export {};
 //# sourceMappingURL=StateTransitionProvableBatch.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAoB,MAAM,UAAU,CAAC;AAIlD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAG/D,qBAAa,mBAAmB;IAC9B,gBAAuB,MAAM,QAAQ;IACrC,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,iCAUhD;WACc,YAAY,CACxB,WAAW,EAAE;QACX,UAAU,EAAE,uBAAuB,CAAC;QACpC,IAAI,EAAE,2BAA2B,CAAC;KACnC,EAAE,GACF,4BAA4B;WAcjB,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,EACtC,mBAAmB,EAAE,uBAAuB,EAAE,GAC7C,4BAA4B;IAsB/B,OAAO;CAMR"}
+{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA2B,MAAM,MAAM,CAAC;AACrD,OAAO,EAAS,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAInE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,qBAAa,mBAAmB;IAC9B,gBAAuB,OAAO,KAAK;IAInC,gBAAuB,aAAa,KAAK;IAEzC,gBAAuB,iBAAiB,KAAK;CAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,gCAE/C;IACA,WAAkB,OAAO,IAAI,2BAA2B,CAEvD;IAED,WAAkB,aAAa,IAAI,2BAA2B,CAE7D;IAED,WAAkB,iBAAiB,IAAI,2BAA2B,CAEjE;IAED,OAAO,CAAC,MAAM,CAAC,IAAI;IAMZ,SAAS;IAOT,SAAS;CAGjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAKtC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,4BAA6B,SAAQ,iCAIhD;WACc,KAAK,IAAI,4BAA4B;CAOpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;;;;;GAMG;AACH,qBAAa,4BAA6B,SAAQ,iCAKhD;WACc,WAAW,CACvB,OAAO,EAAE;QACP,gBAAgB,EAAE,uBAAuB,EAAE,CAAC;QAC5C,OAAO,EAAE,IAAI,CAAC;QACd,WAAW,EAAE,IAAI,CAAC;KACnB,EAAE,GACF,4BAA4B,EAAE;CAwClC"}

package/dist/model/StateTransitionProvableBatch.js

@@ -1,75 +1,98 @@
-import { Bool, Provable, Struct } from "snarkyjs";
+import { Bool, Field, Provable, Struct } from "o1js";
+import { batch, LinkedMerkleTreeWitness } from "@proto-kit/common";
 import { constants } from "../Constants";
 import { ProvableStateTransition } from "./StateTransition.js";
-import { range } from "@proto-kit/common";
 export class StateTransitionType {
-    static isNormal(type) {
-        return type === StateTransitionType.normal;
-    }
-    static isProtocol(type) {
-        return type === StateTransitionType.protocol;
-    }
 }
-StateTransitionType.normal = true;
-StateTransitionType.protocol = false;
+StateTransitionType.nothing = 2;
+// The reason these are 0 and 1 is to efficiently check
+// x in [inside, closing] in-circuit via the boolean trick
+StateTransitionType.closeAndApply = 1;
+StateTransitionType.closeAndThrowAway = 0;
+/**
+ * STType is encoding both the type and whether it should be accumulated or not in one field
+ */
 export class ProvableStateTransitionType extends Struct({
-    type: Bool,
+    type: Field,
 }) {
-    static get normal() {
-        return new ProvableStateTransitionType({
-            type: Bool(StateTransitionType.normal),
-        });
+    static get nothing() {
+        return this.from(StateTransitionType.nothing);
+    }
+    static get closeAndApply() {
+        return this.from(StateTransitionType.closeAndApply);
     }
-    static get protocol() {
+    static get closeAndThrowAway() {
+        return this.from(StateTransitionType.closeAndThrowAway);
+    }
+    static from(constant) {
         return new ProvableStateTransitionType({
-            type: Bool(StateTransitionType.protocol),
+            type: Field(constant),
         });
     }
-    isNormal() {
-        return this.type;
+    isClosing() {
+        const { type } = this;
+        // check if base is 0 or 1
+        // 0^2 == 0 && 1^2 == 1
+        return type.mul(type).equals(type);
     }
-    isProtocol() {
-        return this.type.not();
+    isNothing() {
+        return this.type.equals(ProvableStateTransitionType.nothing.type);
+    }
+}
+export class MerkleWitnessBatch extends Struct({
+    witnesses: Provable.Array(LinkedMerkleTreeWitness, constants.stateTransitionProverBatchSize),
+}) {
+}
+export class ProvableStateTransitionEntry extends Struct({
+    stateTransition: ProvableStateTransition,
+    type: ProvableStateTransitionType,
+    witnessRoot: Bool,
+}) {
+    static dummy() {
+        return {
+            stateTransition: ProvableStateTransition.dummy(),
+            type: ProvableStateTransitionType.nothing,
+            witnessRoot: Bool(false),
+        };
     }
 }
 /**
  * A Batch of StateTransitions to be consumed by the StateTransitionProver
  * to prove multiple STs at once
  *
- * transitionType:
- * true == normal ST, false == protocol ST
+ * The batch is formed as an array fo ProvableSTEntries, which have a type and
+ * witnessesRoot flag attached to them.
  */
 export class StateTransitionProvableBatch extends Struct({
-    batch: Provable.Array(ProvableStateTransition, constants.stateTransitionProverBatchSize),
-    transitionTypes: Provable.Array(ProvableStateTransitionType, constants.stateTransitionProverBatchSize),
+    batch: Provable.Array(ProvableStateTransitionEntry, constants.stateTransitionProverBatchSize),
 }) {
-    static fromMappings(transitions) {
-        const batch = transitions.map((entry) => entry.transition);
-        const transitionTypes = transitions.map((entry) => entry.type);
-        while (batch.length < constants.stateTransitionProverBatchSize) {
-            batch.push(ProvableStateTransition.dummy());
-            transitionTypes.push(ProvableStateTransitionType.normal);
+    static fromBatches(batches) {
+        const flattened = [];
+        for (const stBatch of batches) {
+            const entries = stBatch.stateTransitions.map((stateTransition, j, sts) => {
+                return {
+                    stateTransition,
+                    type: 
+                    // eslint-disable-next-line no-nested-ternary
+                    j === sts.length - 1
+                        ? stBatch.applied.toBoolean()
+                            ? ProvableStateTransitionType.closeAndApply
+                            : ProvableStateTransitionType.closeAndThrowAway
+                        : ProvableStateTransitionType.nothing,
+                    witnessRoot: Bool(false),
+                };
+            });
+            flattened.push(...entries);
+            if (stBatch.witnessRoot.toBoolean() && flattened.length > 0) {
+                flattened.at(-1).witnessRoot = Bool(true);
+            }
         }
-        return new StateTransitionProvableBatch({
-            batch,
-            transitionTypes,
+        const values = batch(flattened, constants.stateTransitionProverBatchSize, () => ProvableStateTransitionEntry.dummy());
+        return values.map((stBatch) => {
+            return new StateTransitionProvableBatch({
+                batch: stBatch,
+            });
         });
     }
-    static fromTransitions(transitions, protocolTransitions) {
-        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,
-        });
-    }
-    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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"}