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

package/dist/prover/block/BlockProvable.d.ts

@@ -1,5 +1,5 @@
 import { Proof } from "snarkyjs";
-import { ZkProgrammable } from "@proto-kit/common";
+import { WithZkProgrammable } from "@proto-kit/common";
 import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
 import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
@@ -141,7 +141,7 @@ declare const BlockProverExecutionData_base: (new (value: {
 };
 export declare class BlockProverExecutionData extends BlockProverExecutionData_base {
 }
-export interface BlockProvable extends ZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
+export interface BlockProvable extends WithZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
     proveTransaction: (publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData) => BlockProverPublicOutput;
     merge: (publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof) => BlockProverPublicOutput;
 }

package/dist/prover/block/BlockProvable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhE,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAG3C;CAAG;AAEL,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,sBAAsB,EACtB,uBAAuB,CACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,wBAAyB,SAAQ,6BAI5C;CAAG;AAEL,MAAM,WAAW,aACf,SAAQ,cAAc,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IACvE,gBAAgB,EAAE,CAChB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,KACpC,uBAAuB,CAAC;IAE7B,KAAK,EAAE,CACL,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,KACrB,uBAAuB,CAAC;CAC9B"}
+{"version":3,"file":"BlockProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhE,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,uBAAwB,SAAQ,4BAG3C;CAAG;AAEL,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAClC,sBAAsB,EACtB,uBAAuB,CACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,wBAAyB,SAAQ,6BAI5C;CAAG;AAEL,MAAM,WAAW,aACf,SAAQ,kBAAkB,CAAC,sBAAsB,EAAE,uBAAuB,CAAC;IAC3E,gBAAgB,EAAE,CAChB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,KACpC,uBAAuB,CAAC;IAE7B,KAAK,EAAE,CACL,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,KACrB,uBAAuB,CAAC;CAC9B"}

package/dist/prover/block/BlockProver.d.ts

@@ -1,9 +1,10 @@
 import { Field, type Proof } from "snarkyjs";
-import { PlainZkProgram, WithZkProgrammable, ZkProgrammable } from "@proto-kit/common";
+import { AreProofsEnabled, PlainZkProgram, WithZkProgrammable, ZkProgrammable } from "@proto-kit/common";
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { StateTransitionProof, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "../statetransition/StateTransitionProvable";
 import { BlockProvable, BlockProverExecutionData, BlockProverProof, BlockProverPublicInput, BlockProverPublicOutput } from "./BlockProvable";
+import { ProvableTransactionHook } from "../../protocol/ProvableTransactionHook";
 export interface BlockProverState {
     stateRoot: Field;
     /**
@@ -17,15 +18,13 @@ export interface BlockProverState {
      */
     networkStateHash: Field;
 }
-/**
- * BlockProver class, which aggregates a AppChainProof and
- * a StateTransitionProof into a single BlockProof, that can
- * then be merged to be committed to the base-layer contract
- */
-export declare class BlockProver extends ProtocolModule<BlockProverPublicInput, BlockProverPublicOutput> implements BlockProvable {
-    private readonly stateTransitionProver;
-    private readonly runtime;
-    constructor(stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: WithZkProgrammable<void, MethodPublicOutput>);
+export declare class BlockProverProgrammable extends ZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
+    private readonly prover;
+    readonly stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
+    readonly runtime: ZkProgrammable<undefined, MethodPublicOutput>;
+    private readonly blockModules;
+    constructor(prover: BlockProver, stateTransitionProver: ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: ZkProgrammable<undefined, MethodPublicOutput>, blockModules: ProvableTransactionHook[]);
+    get appChain(): AreProofsEnabled | undefined;
     /**
      * Applies and checks the two proofs and applies the corresponding state
      * changes to the given state
@@ -33,9 +32,11 @@ export declare class BlockProver extends ProtocolModule<BlockProverPublicInput,
      * @param state The from-state of the BlockProver
      * @param stateTransitionProof
      * @param appProof
+     * @param executionData
      * @returns The new BlockProver-state to be used as public output
      */
-    applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, appProof: Proof<void, MethodPublicOutput>, { transaction, networkState }: BlockProverExecutionData): BlockProverState;
+    applyTransaction(state: BlockProverState, stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverState;
+    assertProtocolTransitions(stateTransitionProof: Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, executionData: BlockProverExecutionData): void;
     proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverPublicOutput;
     merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
     /**
@@ -45,4 +46,17 @@ export declare class BlockProver extends ProtocolModule<BlockProverPublicInput,
      */
     zkProgramFactory(): PlainZkProgram<BlockProverPublicInput, BlockProverPublicOutput>;
 }
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+export declare class BlockProver extends ProtocolModule implements BlockProvable {
+    readonly stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
+    readonly runtime: WithZkProgrammable<undefined, MethodPublicOutput>;
+    zkProgrammable: BlockProverProgrammable;
+    constructor(stateTransitionProver: WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>, runtime: WithZkProgrammable<undefined, MethodPublicOutput>, transactionHooks: ProvableTransactionHook[]);
+    merge(publicInput: BlockProverPublicInput, proof1: BlockProverProof, proof2: BlockProverProof): BlockProverPublicOutput;
+    proveTransaction(publicInput: BlockProverPublicInput, stateProof: StateTransitionProof, appProof: Proof<void, MethodPublicOutput>, executionData: BlockProverExecutionData): BlockProverPublicOutput;
+}
 //# sourceMappingURL=BlockProver.d.ts.map

package/dist/prover/block/BlockProver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockProver.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,EAAE,KAAK,KAAK,EAAuB,MAAM,UAAU,CAAC;AAEhF,OAAO,EACL,cAAc,EAEd,kBAAkB,EAClB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,oBAAoB,EACpB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,4CAA4C,CAAC;AAGpD,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAiBzB,MAAM,WAAW,gBAAgB;IAE/B,SAAS,EAAE,KAAK,CAAC;IAEjB;;;OAGG;IACH,gBAAgB,EAAE,KAAK,CAAC;IAExB;;;OAGG;IACH,gBAAgB,EAAE,KAAK,CAAC;CACzB;AAED;;;;GAIG;AACH,qBACa,WACX,SAAQ,cAAc,CAAC,sBAAsB,EAAE,uBAAuB,CACtE,YAAW,aAAa;IAItB,OAAO,CAAC,QAAQ,CAAC,qBAAqB;IAKtC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBALP,qBAAqB,EAAE,cAAc,CACpD,gCAAgC,EAChC,iCAAiC,CAClC,EAEgB,OAAO,EAAE,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAKxE;;;;;;;;OAQG;IACI,gBAAgB,CACrB,KAAK,EAAE,gBAAgB,EACvB,oBAAoB,EAAE,KAAK,CACzB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,wBAAwB,GACtD,gBAAgB;IAyEZ,gBAAgB,CACrB,WAAW,EAAE,sBAAsB,EACnC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,kBAAkB,CAAC,EACzC,aAAa,EAAE,wBAAwB,GACtC,uBAAuB;IAqBnB,KAAK,CACV,WAAW,EAAE,sBAAsB,EACnC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,GACvB,uBAAuB;IA8B1B;;;;OAIG;IACI,gBAAgB,IAAI,cAAc,CACvC,sBAAsB,EACtB,uBAAuB,CACxB;CAkEF"}
+{"version":3,"file":"BlockProver.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockProver.ts"],"names":[],"mappings":"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"}

package/dist/prover/block/BlockProver.js

@@ -12,12 +12,14 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 /* eslint-disable max-lines */
 import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
-import { inject, injectable } from "tsyringe";
+import { container, inject, injectable, injectAll } from "tsyringe";
 import { provableMethod, ZkProgrammable, } from "@proto-kit/common";
 import { DefaultProvableHashList } from "../../utils/ProvableHashList";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { BlockProverExecutionData, BlockProverPublicInput, BlockProverPublicOutput, } from "./BlockProvable";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethodExecutionContext";
 const errors = {
     stateProofNotStartingAtZero: () => "StateProof not starting ST-commitment at zero",
     stateTransitionsHashNotEqual: () => "StateTransition list commitments are not equal",
@@ -25,16 +27,18 @@ const errors = {
     stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
     transactionsHashNotMatching: (step) => `transactions hash not matching ${step}`,
 };
-/**
- * BlockProver class, which aggregates a AppChainProof and
- * a StateTransitionProof into a single BlockProof, that can
- * then be merged to be committed to the base-layer contract
- */
-let BlockProver = class BlockProver extends ProtocolModule {
-    constructor(stateTransitionProver, runtime) {
+export class BlockProverProgrammable extends ZkProgrammable {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    prover, stateTransitionProver, runtime, blockModules) {
         super();
+        this.prover = prover;
         this.stateTransitionProver = stateTransitionProver;
         this.runtime = runtime;
+        this.blockModules = blockModules;
+    }
+    get appChain() {
+        return this.prover.appChain;
     }
     /**
      * Applies and checks the two proofs and applies the corresponding state
@@ -43,9 +47,11 @@ let BlockProver = class BlockProver extends ProtocolModule {
      * @param state The from-state of the BlockProver
      * @param stateTransitionProof
      * @param appProof
+     * @param executionData
      * @returns The new BlockProver-state to be used as public output
      */
-    applyTransaction(state, stateTransitionProof, appProof, { transaction, networkState }) {
+    applyTransaction(state, stateTransitionProof, appProof, executionData) {
+        const { transaction, networkState } = executionData;
         appProof.verify();
         stateTransitionProof.verify();
         const stateTo = { ...state };
@@ -57,6 +63,8 @@ let BlockProver = class BlockProver extends ProtocolModule {
         // Apply state if status success
         state.stateRoot.assertEquals(stateTransitionProof.publicInput.stateRoot, errors.propertyNotMatching("from state root"));
         stateTo.stateRoot = Provable.if(appProof.publicOutput.status, stateTransitionProof.publicOutput.stateRoot, stateTransitionProof.publicInput.stateRoot);
+        // Apply protocol state transitions
+        this.assertProtocolTransitions(stateTransitionProof, executionData);
         // Check transaction signature
         transaction
             .validateSignature()
@@ -76,6 +84,32 @@ let BlockProver = class BlockProver extends ProtocolModule {
         stateTo.transactionsHash = transactionList.commitment;
         return stateTo;
     }
+    // eslint-disable-next-line no-warning-comments, max-len
+    // TODO How does this interact with the RuntimeMethodExecutionContext when executing runtimemethods?
+    assertProtocolTransitions(stateTransitionProof, executionData) {
+        const executionContext = container.resolve(RuntimeMethodExecutionContext);
+        executionContext.clear();
+        // Setup context for potential calls to runtime methods.
+        // This way they can use this.transaction etc. while still having provable
+        // integrity between data
+        executionContext.setup({
+            transaction: RuntimeTransaction.fromProtocolTransaction(executionData.transaction),
+            networkState: executionData.networkState,
+        });
+        executionContext.beforeMethod("", "", []);
+        this.blockModules.forEach((module) => {
+            module.onTransaction(executionData);
+        });
+        executionContext.afterMethod();
+        const { stateTransitions, status, statusMessage } = executionContext.current().result;
+        status.assertTrue(statusMessage);
+        const transitions = stateTransitions.map((transition) => transition.toProvable());
+        const hashList = new DefaultProvableHashList(ProvableStateTransition, stateTransitionProof.publicInput.protocolTransitionsHash);
+        transitions.forEach((transition) => {
+            hashList.push(transition);
+        });
+        stateTransitionProof.publicOutput.protocolTransitionsHash.assertEquals(hashList.commitment, "ProtocolTransitionsHash not matching the generated protocol transitions");
+    }
     proveTransaction(publicInput, stateProof, appProof, executionData) {
         const state = {
             transactionsHash: publicInput.transactionsHash,
@@ -108,10 +142,11 @@ let BlockProver = class BlockProver extends ProtocolModule {
      * injected StateTransitionProver and the required AppChainProof class
      */
     zkProgramFactory() {
-        const StateTransitionProofClass = this.stateTransitionProver.zkProgram.Proof;
-        const RuntimeProofClass = this.runtime.zkProgrammable.zkProgram.Proof;
-        const proveTransaction = this.proveTransaction.bind(this);
-        const merge = this.merge.bind(this);
+        const { prover, stateTransitionProver, runtime } = this;
+        const StateTransitionProofClass = stateTransitionProver.zkProgram.Proof;
+        const RuntimeProofClass = runtime.zkProgram.Proof;
+        const proveTransaction = prover.proveTransaction.bind(prover);
+        const merge = prover.merge.bind(prover);
         const program = Experimental.ZkProgram({
             publicInput: BlockProverPublicInput,
             publicOutput: BlockProverPublicOutput,
@@ -149,23 +184,45 @@ let BlockProver = class BlockProver extends ProtocolModule {
             methods,
         };
     }
-};
+}
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [BlockProverPublicInput, Object, Function, BlockProverExecutionData]),
     __metadata("design:returntype", BlockProverPublicOutput)
-], BlockProver.prototype, "proveTransaction", null);
+], BlockProverProgrammable.prototype, "proveTransaction", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object]),
     __metadata("design:returntype", BlockProverPublicOutput)
-], BlockProver.prototype, "merge", null);
+], BlockProverProgrammable.prototype, "merge", null);
+/**
+ * BlockProver class, which aggregates a AppChainProof and
+ * a StateTransitionProof into a single BlockProof, that can
+ * then be merged to be committed to the base-layer contract
+ */
+let BlockProver = class BlockProver extends ProtocolModule {
+    constructor(stateTransitionProver, runtime, transactionHooks) {
+        super();
+        this.stateTransitionProver = stateTransitionProver;
+        this.runtime = runtime;
+        this.zkProgrammable = new BlockProverProgrammable(this, stateTransitionProver.zkProgrammable, runtime.zkProgrammable, transactionHooks
+        // protocol.dependencyContainer.resolveAll("P rovableTransactionHook")
+        );
+    }
+    merge(publicInput, proof1, proof2) {
+        return this.zkProgrammable.merge(publicInput, proof1, proof2);
+    }
+    proveTransaction(publicInput, stateProof, appProof, executionData) {
+        return this.zkProgrammable.proveTransaction(publicInput, stateProof, appProof, executionData);
+    }
+};
 BlockProver = __decorate([
     injectable(),
     __param(0, inject("StateTransitionProver")),
     __param(1, inject("Runtime")),
-    __metadata("design:paramtypes", [ZkProgrammable, Object])
+    __param(2, injectAll("ProvableTransactionHook")),
+    __metadata("design:paramtypes", [Object, Object, Array])
 ], BlockProver);
 export { BlockProver };

package/dist/prover/statetransition/StateTransitionProvable.d.ts

@@ -1,21 +1,25 @@
 import { Proof } from "snarkyjs";
-import { ZkProgrammable } from "@proto-kit/common";
+import { WithZkProgrammable } from "@proto-kit/common";
 import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 declare const StateTransitionProverPublicInput_base: (new (value: {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) => {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) & {
     _isStruct: true;
 } & import("snarkyjs/dist/node/snarky").ProvablePure<{
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }> & {
     toInput: (x: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
@@ -23,16 +27,20 @@ declare const StateTransitionProverPublicInput_base: (new (value: {
     };
     toJSON: (x: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         stateTransitionsHash: string;
+        protocolTransitionsHash: string;
         stateRoot: string;
     };
     fromJSON: (x: {
         stateTransitionsHash: string;
+        protocolTransitionsHash: string;
         stateRoot: string;
     }) => {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
     };
 };
@@ -40,18 +48,22 @@ export declare class StateTransitionProverPublicInput extends StateTransitionPro
 }
 declare const StateTransitionProverPublicOutput_base: (new (value: {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) => {
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }) & {
     _isStruct: true;
 } & import("snarkyjs/dist/node/snarky").ProvablePure<{
     stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
     stateRoot: import("snarkyjs/dist/node/lib/field").Field;
 }> & {
     toInput: (x: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
@@ -59,23 +71,27 @@ declare const StateTransitionProverPublicOutput_base: (new (value: {
     };
     toJSON: (x: {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
     }) => {
         stateTransitionsHash: string;
+        protocolTransitionsHash: string;
         stateRoot: string;
     };
     fromJSON: (x: {
         stateTransitionsHash: string;
+        protocolTransitionsHash: string;
         stateRoot: string;
     }) => {
         stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        protocolTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
         stateRoot: import("snarkyjs/dist/node/lib/field").Field;
     };
 };
 export declare class StateTransitionProverPublicOutput extends StateTransitionProverPublicOutput_base {
 }
 export type StateTransitionProof = Proof<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
-export interface StateTransitionProvable extends ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
+export interface StateTransitionProvable extends WithZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
     witnessProviderReference: StateTransitionWitnessProviderReference;
     runBatch: (publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch) => StateTransitionProverPublicOutput;
     merge: (publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof) => StateTransitionProverPublicOutput;

package/dist/prover/statetransition/StateTransitionProvable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAGpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAGrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,cAAc,CACpB,gCAAgC,EAChC,iCAAiC,CAClC;IACD,wBAAwB,EAAE,uCAAuC,CAAC;IAElE,QAAQ,EAAE,CACR,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,KAChC,iCAAiC,CAAC;IAEvC,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,iCAAiC,CAAC;CACxC"}
+{"version":3,"file":"StateTransitionProvable.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAU,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAkB,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,gCAAiC,SAAQ,qCAIpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAIrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,kBAAkB,CACxB,gCAAgC,EAChC,iCAAiC,CAClC;IACD,wBAAwB,EAAE,uCAAuC,CAAC;IAElE,QAAQ,EAAE,CACR,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,KAChC,iCAAiC,CAAC;IAEvC,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,iCAAiC,CAAC;CACxC"}

package/dist/prover/statetransition/StateTransitionProvable.js

@@ -1,11 +1,13 @@
 import { Field, Struct } from "snarkyjs";
 export class StateTransitionProverPublicInput extends Struct({
     stateTransitionsHash: Field,
+    protocolTransitionsHash: Field,
     stateRoot: Field,
 }) {
 }
 export class StateTransitionProverPublicOutput extends Struct({
     stateTransitionsHash: Field,
+    protocolTransitionsHash: Field,
     stateRoot: Field,
 }) {
 }

package/dist/prover/statetransition/StateTransitionProver.d.ts

@@ -1,39 +1,49 @@
 import { Field } from "snarkyjs";
-import { PlainZkProgram } from "@proto-kit/common";
+import { AreProofsEnabled, PlainZkProgram, ZkProgrammable } from "@proto-kit/common";
 import { ProvableHashList } from "../../utils/ProvableHashList";
 import { ProvableStateTransition } from "../../model/StateTransition";
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { ProvableStateTransitionType, StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProof, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 interface StateTransitionProverExecutionState {
     stateRoot: Field;
     stateTransitionList: ProvableHashList<ProvableStateTransition>;
+    protocolTransitionList: ProvableHashList<ProvableStateTransition>;
 }
 /**
  * StateTransitionProver is the prover that proves the application of some state
  * transitions and checks and updates their merkle-tree entries
  */
-export declare class StateTransitionProver extends ProtocolModule<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> implements StateTransitionProvable {
+export declare class StateTransitionProverProgrammable extends ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
+    private readonly stateTransitionProver;
     readonly witnessProviderReference: StateTransitionWitnessProviderReference;
-    constructor(witnessProviderReference: StateTransitionWitnessProviderReference);
+    constructor(stateTransitionProver: StateTransitionProver, witnessProviderReference: StateTransitionWitnessProviderReference);
+    get appChain(): AreProofsEnabled | undefined;
     zkProgramFactory(): PlainZkProgram<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>;
     private get witnessProvider();
     /**
      * Applies the state transitions to the current stateRoot
      * and returns the new prover state
      */
-    applyTransitions(stateRoot: Field, stateTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverExecutionState;
+    applyTransitions(stateRoot: Field, stateTransitionCommitmentFrom: Field, protocolTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverExecutionState;
     /**
      * Applies a single state transition to the given state
      * and mutates it in place
      */
-    applyTransition(state: StateTransitionProverExecutionState, transition: ProvableStateTransition, index?: number): void;
+    applyTransition(state: StateTransitionProverExecutionState, transition: ProvableStateTransition, type: ProvableStateTransitionType, index?: number): void;
     /**
      * Applies a whole batch of StateTransitions at once
      */
     runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
     merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
 }
+export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable {
+    readonly witnessProviderReference: StateTransitionWitnessProviderReference;
+    readonly zkProgrammable: StateTransitionProverProgrammable;
+    constructor(witnessProviderReference: StateTransitionWitnessProviderReference);
+    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
+}
 export {};
 //# sourceMappingURL=StateTransitionProver.d.ts.map

package/dist/prover/statetransition/StateTransitionProver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,EAAuB,MAAM,UAAU,CAAC;AAEpE,OAAO,EAAE,cAAc,EAAkB,MAAM,mBAAmB,CAAC;AAMnE,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAExF,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAmBpG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CAChE;AAOD;;;GAGG;AACH,qBACa,qBACX,SAAQ,cAAc,CACpB,gCAAgC,EAChC,iCAAiC,CAEnC,YAAW,uBAAuB;aAIhB,wBAAwB,EAAE,uCAAuC;gBAAjE,wBAAwB,EAAE,uCAAuC;IAK5E,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,6BAA6B,EAAE,KAAK,EACpC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IAsBtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,KAAK,SAAI;IAgCX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAc7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CA6BrC"}
+{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,EAAuB,MAAM,UAAU,CAAC;AAEpE,OAAO,EACL,gBAAgB,EAChB,cAAc,EAEd,cAAc,EACf,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uCAAuC,EAAE,MAAM,2CAA2C,CAAC;AAsBpG,UAAU,mCAAmC;IAC3C,SAAS,EAAE,KAAK,CAAC;IACjB,mBAAmB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC/D,sBAAsB,EAAE,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;CACnE;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAGG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;aACtB,wBAAwB,EAAE,uCAAuC;gBADhE,qBAAqB,EAAE,qBAAqB,EAC7C,wBAAwB,EAAE,uCAAuC;IAKnF,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAElD;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC;IAqDD,OAAO,KAAK,eAAe,GAM1B;IAED;;;OAGG;IACI,gBAAgB,CACrB,SAAS,EAAE,KAAK,EAChB,6BAA6B,EAAE,KAAK,EACpC,gCAAgC,EAAE,KAAK,EACvC,eAAe,EAAE,4BAA4B,GAC5C,mCAAmC;IA4BtC;;;OAGG;IACI,eAAe,CACpB,KAAK,EAAE,mCAAmC,EAC1C,UAAU,EAAE,uBAAuB,EACnC,IAAI,EAAE,2BAA2B,EACjC,KAAK,SAAI;IAyCX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAgB7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CA0CrC;AAED,qBACa,qBACX,SAAQ,cACR,YAAW,uBAAuB;aAMhB,wBAAwB,EAAE,uCAAuC;IAJnF,SAAgB,cAAc,EAAE,iCAAiC,CAAC;gBAIhD,wBAAwB,EAAE,uCAAuC;IAS5E,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAI7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CAGrC"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -7,13 +7,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+/* eslint-disable max-lines */
 import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
 import { injectable } from "tsyringe";
-import { provableMethod } from "@proto-kit/common";
+import { provableMethod, ZkProgrammable, } from "@proto-kit/common";
 import { MerkleTreeUtils, RollupMerkleWitness, } from "../../utils/merkletree/RollupMerkleTree.js";
 import { DefaultProvableHashList, } from "../../utils/ProvableHashList";
 import { ProvableStateTransition } from "../../model/StateTransition";
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { StateTransitionProvableBatch, } from "../../model/StateTransitionProvableBatch";
 import { constants } from "../../Constants";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 import { StateTransitionProverPublicInput, StateTransitionProverPublicOutput, } from "./StateTransitionProvable";
@@ -21,6 +22,7 @@ import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnes
 const errors = {
     stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
     stateTransitionsHashNotMatching: (step) => `State transitions hash not matching ${step}`,
+    protocolTransitionsHashNotMatching: (step) => `Protocol transitions hash not matching ${step}`,
     merkleWitnessNotCorrect: (index) => `MerkleWitness not valid for StateTransition (${index})`,
     noWitnessProviderSet: () => new Error("WitnessProvider not set, set it before you use StateTransitionProvider"),
     propertyNotMatching: (propertyName) => `${propertyName} not matching`,
@@ -30,13 +32,17 @@ const StateTransitionSelfProofClass = (SelfProof);
  * StateTransitionProver is the prover that proves the application of some state
  * transitions and checks and updates their merkle-tree entries
  */
-let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
+export class StateTransitionProverProgrammable extends ZkProgrammable {
     constructor(
-    // Injected
-    witnessProviderReference) {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    stateTransitionProver, witnessProviderReference) {
         super();
+        this.stateTransitionProver = stateTransitionProver;
         this.witnessProviderReference = witnessProviderReference;
     }
+    get appChain() {
+        return this.stateTransitionProver.appChain;
+    }
     zkProgramFactory() {
         // eslint-disable-next-line max-len
         // eslint-disable-next-line @typescript-eslint/no-this-alias,consistent-this,unicorn/no-this-assignment
@@ -85,14 +91,16 @@ let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
      * Applies the state transitions to the current stateRoot
      * and returns the new prover state
      */
-    applyTransitions(stateRoot, stateTransitionCommitmentFrom, transitionBatch) {
+    applyTransitions(stateRoot, stateTransitionCommitmentFrom, protocolTransitionCommitmentFrom, transitionBatch) {
         const state = {
             stateRoot,
             stateTransitionList: new DefaultProvableHashList(ProvableStateTransition, stateTransitionCommitmentFrom),
+            protocolTransitionList: new DefaultProvableHashList(ProvableStateTransition, protocolTransitionCommitmentFrom),
         };
         const transitions = transitionBatch.batch;
+        const types = transitionBatch.transitionTypes;
         for (let index = 0; index < constants.stateTransitionProverBatchSize; index++) {
-            this.applyTransition(state, transitions[index], index);
+            this.applyTransition(state, transitions[index], types[index], index);
         }
         return state;
     }
@@ -100,24 +108,29 @@ let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
      * Applies a single state transition to the given state
      * and mutates it in place
      */
-    applyTransition(state, transition, index = 0) {
+    applyTransition(state, transition, type, index = 0) {
         const treeWitness = Provable.witness(RollupMerkleWitness, () => this.witnessProvider.getWitness(transition.path));
         const membershipValid = MerkleTreeUtils.checkMembership(treeWitness, state.stateRoot, transition.path, transition.from.value);
         membershipValid
             .or(transition.from.isSome.not())
             .assertTrue(errors.merkleWitnessNotCorrect(index));
+        const t = Date.now();
         const newRoot = MerkleTreeUtils.computeRoot(treeWitness, transition.to.value);
+        Provable.log("Compute root took", Date.now() - t, "ms");
         state.stateRoot = Provable.if(transition.to.isSome, newRoot, state.stateRoot);
-        state.stateTransitionList.pushIf(transition, transition.path.equals(Field(0)).not());
+        const isNotDummy = transition.path.equals(Field(0)).not();
+        state.stateTransitionList.pushIf(transition, isNotDummy.and(type.isNormal()));
+        state.protocolTransitionList.pushIf(transition, isNotDummy.and(type.isProtocol()));
     }
     /**
      * Applies a whole batch of StateTransitions at once
      */
     runBatch(publicInput, batch) {
-        const result = this.applyTransitions(publicInput.stateRoot, publicInput.stateTransitionsHash, batch);
+        const result = this.applyTransitions(publicInput.stateRoot, publicInput.stateTransitionsHash, publicInput.protocolTransitionsHash, batch);
         return new StateTransitionProverPublicOutput({
             stateRoot: result.stateRoot,
             stateTransitionsHash: result.stateTransitionList.commitment,
+            protocolTransitionsHash: result.protocolTransitionList.commitment,
         });
     }
     merge(publicInput, proof1, proof2) {
@@ -129,25 +142,44 @@ let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
         // Check ST list
         publicInput.stateTransitionsHash.assertEquals(proof1.publicInput.stateTransitionsHash, errors.stateTransitionsHashNotMatching("publicInput.from -> proof1.from"));
         proof1.publicOutput.stateTransitionsHash.assertEquals(proof2.publicInput.stateTransitionsHash, errors.stateTransitionsHashNotMatching("proof1.to -> proof2.from"));
+        // Check Protocol ST list
+        publicInput.protocolTransitionsHash.assertEquals(proof1.publicInput.protocolTransitionsHash, errors.protocolTransitionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.protocolTransitionsHash.assertEquals(proof2.publicInput.protocolTransitionsHash, errors.protocolTransitionsHashNotMatching("proof1.to -> proof2.from"));
         return new StateTransitionProverPublicInput({
             stateRoot: proof2.publicOutput.stateRoot,
             stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
+            protocolTransitionsHash: proof2.publicOutput.protocolTransitionsHash,
         });
     }
-};
+}
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [StateTransitionProverPublicInput,
         StateTransitionProvableBatch]),
     __metadata("design:returntype", StateTransitionProverPublicOutput)
-], StateTransitionProver.prototype, "runBatch", null);
+], StateTransitionProverProgrammable.prototype, "runBatch", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [StateTransitionProverPublicInput, Object, Object]),
     __metadata("design:returntype", StateTransitionProverPublicOutput)
-], StateTransitionProver.prototype, "merge", null);
+], StateTransitionProverProgrammable.prototype, "merge", null);
+let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
+    constructor(
+    // Injected
+    witnessProviderReference) {
+        super();
+        this.witnessProviderReference = witnessProviderReference;
+        this.zkProgrammable = new StateTransitionProverProgrammable(this, witnessProviderReference);
+    }
+    runBatch(publicInput, batch) {
+        return this.zkProgrammable.runBatch(publicInput, batch);
+    }
+    merge(publicInput, proof1, proof2) {
+        return this.zkProgrammable.merge(publicInput, proof1, proof2);
+    }
+};
 StateTransitionProver = __decorate([
     injectable(),
     __metadata("design:paramtypes", [StateTransitionWitnessProviderReference])