@proto-kit/protocol 0.1.1-develop.1316 → 0.1.1-develop.1347

package/dist/model/StateTransitionProvableBatch.d.ts

@@ -2,73 +2,131 @@ 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;
+    static readonly nothing = 2;
+    static readonly closeAndApply = 1;
+    static readonly closeAndThrowAway = 0;
 }
 declare const ProvableStateTransitionType_base: (new (value: {
-    type: import("o1js/dist/node/lib/provable/bool").Bool;
+    type: import("o1js/dist/node/lib/provable/field").Field;
 }) => {
-    type: import("o1js/dist/node/lib/provable/bool").Bool;
+    type: import("o1js/dist/node/lib/provable/field").Field;
 }) & {
     _isStruct: true;
 } & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
-    type: import("o1js/dist/node/lib/provable/bool").Bool;
+    type: import("o1js/dist/node/lib/provable/field").Field;
 }, {
-    type: boolean;
+    type: bigint;
 }>, "fromFields"> & {
     fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
-        type: import("o1js/dist/node/lib/provable/bool").Bool;
+        type: import("o1js/dist/node/lib/provable/field").Field;
     };
 } & {
     fromValue: (value: {
-        type: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        type: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        type: import("o1js/dist/node/lib/provable/bool").Bool;
+        type: import("o1js/dist/node/lib/provable/field").Field;
     };
     toInput: (x: {
-        type: import("o1js/dist/node/lib/provable/bool").Bool;
+        type: 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: {
-        type: import("o1js/dist/node/lib/provable/bool").Bool;
+        type: import("o1js/dist/node/lib/provable/field").Field;
     }) => {
-        type: boolean;
+        type: string;
     };
     fromJSON: (x: {
-        type: boolean;
+        type: string;
     }) => {
-        type: import("o1js/dist/node/lib/provable/bool").Bool;
+        type: import("o1js/dist/node/lib/provable/field").Field;
     };
     empty: () => {
-        type: import("o1js/dist/node/lib/provable/bool").Bool;
+        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[];
-    merkleWitnesses: RollupMerkleTreeWitness[];
+declare const MerkleWitnessBatch_base: (new (value: {
+    witnesses: RollupMerkleTreeWitness[];
 }) => {
-    batch: ProvableStateTransition[];
-    transitionTypes: ProvableStateTransitionType[];
-    merkleWitnesses: RollupMerkleTreeWitness[];
+    witnesses: RollupMerkleTreeWitness[];
 }) & {
     _isStruct: true;
 } & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
-    batch: ProvableStateTransition[];
-    transitionTypes: ProvableStateTransitionType[];
-    merkleWitnesses: RollupMerkleTreeWitness[];
+    witnesses: RollupMerkleTreeWitness[];
 }, {
-    batch: {
+    witnesses: {
+        path: bigint[];
+        isLeft: boolean[];
+    }[];
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        witnesses: RollupMerkleTreeWitness[];
+    };
+} & {
+    fromValue: (value: {
+        witnesses: RollupMerkleTreeWitness[] | {
+            path: bigint[];
+            isLeft: boolean[];
+        }[];
+    }) => {
+        witnesses: RollupMerkleTreeWitness[];
+    };
+    toInput: (x: {
+        witnesses: RollupMerkleTreeWitness[];
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        witnesses: RollupMerkleTreeWitness[];
+    }) => {
+        witnesses: {
+            path: string[];
+            isLeft: boolean[];
+        }[];
+    };
+    fromJSON: (x: {
+        witnesses: {
+            path: string[];
+            isLeft: boolean[];
+        }[];
+    }) => {
+        witnesses: RollupMerkleTreeWitness[];
+    };
+    empty: () => {
+        witnesses: RollupMerkleTreeWitness[];
+    };
+};
+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;
@@ -78,59 +136,53 @@ declare const StateTransitionProvableBatch_base: (new (value: {
             isSome: boolean;
             value: bigint;
         };
-    }[];
-    transitionTypes: {
-        type: boolean;
-    }[];
-    merkleWitnesses: {
-        path: bigint[];
-        isLeft: boolean[];
-    }[];
+    };
+    type: {
+        type: bigint;
+    };
+    witnessRoot: boolean;
 }>, "fromFields"> & {
     fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
-        batch: ProvableStateTransition[];
-        transitionTypes: ProvableStateTransitionType[];
-        merkleWitnesses: RollupMerkleTreeWitness[];
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
     };
 } & {
     fromValue: (value: {
-        batch: ProvableStateTransition[] | {
-            path: bigint;
-            from: {
-                isSome: boolean;
-                value: bigint;
+        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: {
-                isSome: boolean;
-                value: bigint;
+            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;
             };
-        }[];
-        transitionTypes: ProvableStateTransitionType[] | {
-            type: boolean;
-        }[];
-        merkleWitnesses: RollupMerkleTreeWitness[] | {
-            path: bigint[];
-            isLeft: boolean[];
-        }[];
+        };
+        type: ProvableStateTransitionType | {
+            type: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        witnessRoot: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
     }) => {
-        batch: ProvableStateTransition[];
-        transitionTypes: ProvableStateTransitionType[];
-        merkleWitnesses: RollupMerkleTreeWitness[];
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
     };
     toInput: (x: {
-        batch: ProvableStateTransition[];
-        transitionTypes: ProvableStateTransitionType[];
-        merkleWitnesses: RollupMerkleTreeWitness[];
+        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: {
-        batch: ProvableStateTransition[];
-        transitionTypes: ProvableStateTransitionType[];
-        merkleWitnesses: RollupMerkleTreeWitness[];
+        stateTransition: ProvableStateTransition;
+        type: ProvableStateTransitionType;
+        witnessRoot: import("o1js/dist/node/lib/provable/bool").Bool;
     }) => {
-        batch: {
+        stateTransition: {
             path: string;
             from: {
                 isSome: boolean;
@@ -140,17 +192,14 @@ declare const StateTransitionProvableBatch_base: (new (value: {
                 isSome: boolean;
                 value: string;
             };
-        }[];
-        transitionTypes: {
-            type: boolean;
-        }[];
-        merkleWitnesses: {
-            path: string[];
-            isLeft: boolean[];
-        }[];
+        };
+        type: {
+            type: string;
+        };
+        witnessRoot: boolean;
     };
     fromJSON: (x: {
-        batch: {
+        stateTransition: {
             path: string;
             from: {
                 isSome: boolean;
@@ -160,39 +209,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;
         }[];
-        transitionTypes: {
-            type: 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;
         }[];
-        merkleWitnesses: {
-            path: string[];
-            isLeft: 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[];
-        merkleWitnesses: RollupMerkleTreeWitness[];
+        batch: ProvableStateTransitionEntry[];
     };
     empty: () => {
-        batch: ProvableStateTransition[];
-        transitionTypes: ProvableStateTransitionType[];
-        merkleWitnesses: RollupMerkleTreeWitness[];
+        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;
-    }[], merkleWitnesses: RollupMerkleTreeWitness[]): StateTransitionProvableBatch;
-    static fromTransitions(transitions: ProvableStateTransition[], protocolTransitions: ProvableStateTransition[], merkleWitnesses: RollupMerkleTreeWitness[]): 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,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"}
+{"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,91 +1,98 @@
-import { Bool, Provable, Struct } from "o1js";
-import { InMemoryMerkleTreeStorage, range, RollupMerkleTree, RollupMerkleTreeWitness, } from "@proto-kit/common";
+import { Bool, Field, Provable, Struct } from "o1js";
+import { batch, 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;
+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 closeAndThrowAway() {
+        return this.from(StateTransitionType.closeAndThrowAway);
     }
-    static get protocol() {
+    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(RollupMerkleTreeWitness, 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),
-    merkleWitnesses: Provable.Array(RollupMerkleTreeWitness, constants.stateTransitionProverBatchSize),
+    batch: Provable.Array(ProvableStateTransitionEntry, 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;
+    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);
             }
-            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,
+        const values = batch(flattened, constants.stateTransitionProverBatchSize, () => ProvableStateTransitionEntry.dummy());
+        return values.map((stBatch) => {
+            return new StateTransitionProvableBatch({
+                batch: stBatch,
+            });
         });
     }
-    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

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

package/dist/model/transaction/RuntimeTransaction.d.ts

@@ -114,6 +114,7 @@ export declare class RuntimeTransaction extends RuntimeTransaction_base {
     }): RuntimeTransaction;
     static dummyTransaction(): RuntimeTransaction;
     assertTransactionType(isMessage: Bool): void;
+    isDummy(): Bool;
     hashData(): Field[];
     static fromHashData(fields: Field[]): RuntimeTransaction;
     hash(): Field;

package/dist/model/transaction/RuntimeTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuntimeTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAY,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;AAGxE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,uBAKtC;WACc,eAAe,CAAC,KAAK,EAAE;QACnC,QAAQ,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,SAAS,CAAC;KACnB;WASa,WAAW,CAAC,EACxB,QAAQ,EACR,QAAQ,GACT,EAAE;QACD,QAAQ,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,KAAK,CAAC;KACjB;WASa,gBAAgB,IAAI,kBAAkB;IAe7C,qBAAqB,CAAC,SAAS,EAAE,IAAI;IAerC,QAAQ,IAAI,KAAK,EAAE;WASZ,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE;IAiBnC,IAAI,IAAI,KAAK;CAGrB"}
+{"version":3,"file":"RuntimeTransaction.d.ts","sourceRoot":"","sources":["../../../src/model/transaction/RuntimeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAY,SAAS,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;AAGxE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,uBAKtC;WACc,eAAe,CAAC,KAAK,EAAE;QACnC,QAAQ,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,KAAK,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,SAAS,CAAC;KACnB;WASa,WAAW,CAAC,EACxB,QAAQ,EACR,QAAQ,GACT,EAAE;QACD,QAAQ,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,KAAK,CAAC;KACjB;WASa,gBAAgB,IAAI,kBAAkB;IAe7C,qBAAqB,CAAC,SAAS,EAAE,IAAI;IAerC,OAAO,IAAI,IAAI;IAIf,QAAQ,IAAI,KAAK,EAAE;WASZ,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE;IAiBnC,IAAI,IAAI,KAAK;CAGrB"}