@proto-kit/protocol 0.1.1-develop.153

package/dist/prover/block/BlockProver.js

@@ -0,0 +1,171 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+/* eslint-disable max-lines */
+import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
+import { inject, injectable } 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";
+const errors = {
+    stateProofNotStartingAtZero: () => "StateProof not starting ST-commitment at zero",
+    stateTransitionsHashNotEqual: () => "StateTransition list commitments are not equal",
+    propertyNotMatching: (propertyName) => `${propertyName} not matching`,
+    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) {
+        super();
+        this.stateTransitionProver = stateTransitionProver;
+        this.runtime = runtime;
+    }
+    /**
+     * Applies and checks the two proofs and applies the corresponding state
+     * changes to the given state
+     *
+     * @param state The from-state of the BlockProver
+     * @param stateTransitionProof
+     * @param appProof
+     * @returns The new BlockProver-state to be used as public output
+     */
+    applyTransaction(state, stateTransitionProof, appProof, { transaction, networkState }) {
+        appProof.verify();
+        stateTransitionProof.verify();
+        const stateTo = { ...state };
+        // eslint-disable-next-line no-warning-comments
+        // TODO Check methodId?
+        // Checks for the stateTransitionProof and appProof matching
+        stateTransitionProof.publicInput.stateTransitionsHash.assertEquals(Field(0), errors.stateProofNotStartingAtZero());
+        appProof.publicOutput.stateTransitionsHash.assertEquals(stateTransitionProof.publicOutput.stateTransitionsHash, errors.stateTransitionsHashNotEqual());
+        // 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);
+        // Check transaction signature
+        transaction
+            .validateSignature()
+            .assertTrue("Transaction signature not valid");
+        // Check if the methodId is correct
+        // to do
+        // Check transaction integrity against appProof
+        const blockTransactionHash = RuntimeTransaction.fromProtocolTransaction(transaction).hash();
+        blockTransactionHash.assertEquals(appProof.publicOutput.transactionHash, "Transactions provided in AppProof and BlockProof do not match");
+        // Check network state integrity against appProof
+        state.networkStateHash.assertEquals(appProof.publicOutput.networkStateHash, "Network state does not match state used in AppProof");
+        state.networkStateHash.assertEquals(networkState.hash(), "Network state provided to BlockProver does not match the publicInput");
+        // Append tx to transaction list
+        const transactionList = new DefaultProvableHashList(Field, state.transactionsHash);
+        const { transactionHash } = appProof.publicOutput;
+        transactionList.push(transactionHash);
+        stateTo.transactionsHash = transactionList.commitment;
+        return stateTo;
+    }
+    proveTransaction(publicInput, stateProof, appProof, executionData) {
+        const state = {
+            transactionsHash: publicInput.transactionsHash,
+            stateRoot: publicInput.stateRoot,
+            networkStateHash: publicInput.networkStateHash,
+        };
+        this.applyTransaction(state, stateProof, appProof, executionData);
+        return new BlockProverPublicOutput({
+            stateRoot: state.stateRoot,
+            transactionsHash: state.transactionsHash,
+        });
+    }
+    merge(publicInput, proof1, proof2) {
+        proof1.verify();
+        proof2.verify();
+        // Check state
+        publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
+        // Check transaction list
+        publicInput.transactionsHash.assertEquals(proof1.publicInput.transactionsHash, errors.transactionsHashNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.transactionsHash.assertEquals(proof2.publicInput.transactionsHash, errors.transactionsHashNotMatching("proof1.to -> proof2.from"));
+        return new BlockProverPublicOutput({
+            stateRoot: proof2.publicOutput.stateRoot,
+            transactionsHash: proof2.publicOutput.transactionsHash,
+        });
+    }
+    /**
+     * Creates the BlockProver ZkProgram.
+     * Recursive linking of proofs is done via the previously
+     * 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 program = Experimental.ZkProgram({
+            publicInput: BlockProverPublicInput,
+            publicOutput: BlockProverPublicOutput,
+            methods: {
+                proveTransaction: {
+                    privateInputs: [
+                        StateTransitionProofClass,
+                        RuntimeProofClass,
+                        BlockProverExecutionData,
+                    ],
+                    method(publicInput, stateProof, appProof, executionData) {
+                        return proveTransaction(publicInput, stateProof, appProof, executionData);
+                    },
+                },
+                merge: {
+                    privateInputs: [
+                        (SelfProof),
+                        (SelfProof),
+                    ],
+                    method(publicInput, proof1, proof2) {
+                        return merge(publicInput, proof1, proof2);
+                    },
+                },
+            },
+        });
+        const methods = {
+            proveTransaction: program.proveTransaction,
+            merge: program.merge,
+        };
+        const SelfProofClass = Experimental.ZkProgram.Proof(program);
+        return {
+            compile: program.compile.bind(program),
+            verify: program.verify.bind(program),
+            Proof: SelfProofClass,
+            methods,
+        };
+    }
+};
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput, Object, Function, BlockProverExecutionData]),
+    __metadata("design:returntype", BlockProverPublicOutput)
+], BlockProver.prototype, "proveTransaction", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BlockProverPublicInput, Object, Object]),
+    __metadata("design:returntype", BlockProverPublicOutput)
+], BlockProver.prototype, "merge", null);
+BlockProver = __decorate([
+    injectable(),
+    __param(0, inject("StateTransitionProver")),
+    __param(1, inject("Runtime")),
+    __metadata("design:paramtypes", [ZkProgrammable, Object])
+], BlockProver);
+export { BlockProver };

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

@@ -0,0 +1,3 @@
+declare const nothing = 1;
+export { nothing };
+//# sourceMappingURL=BlockScopedModule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlockScopedModule.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockScopedModule.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,OAAO,IAAI,CAAC;AAClB,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/prover/block/BlockScopedModule.js

@@ -0,0 +1,6 @@
+// Placeholder for a future module architecture that can plug into the BlockProver
+// export interface BlockScopedModule {
+//
+// }
+const nothing = 1;
+export { nothing };

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

@@ -0,0 +1,84 @@
+import { Proof } from "snarkyjs";
+import { ZkProgrammable } 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;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+}) => {
+    stateTransitionsHash: 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;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        stateTransitionsHash: string;
+        stateRoot: string;
+    };
+    fromJSON: (x: {
+        stateTransitionsHash: string;
+        stateRoot: string;
+    }) => {
+        stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    };
+};
+export declare class StateTransitionProverPublicInput extends StateTransitionProverPublicInput_base {
+}
+declare const StateTransitionProverPublicOutput_base: (new (value: {
+    stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+}) => {
+    stateTransitionsHash: 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;
+    stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+}> & {
+    toInput: (x: {
+        stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        fields?: import("snarkyjs/dist/node/lib/field").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/lib/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        stateTransitionsHash: import("snarkyjs/dist/node/lib/field").Field;
+        stateRoot: import("snarkyjs/dist/node/lib/field").Field;
+    }) => {
+        stateTransitionsHash: string;
+        stateRoot: string;
+    };
+    fromJSON: (x: {
+        stateTransitionsHash: string;
+        stateRoot: string;
+    }) => {
+        stateTransitionsHash: 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> {
+    witnessProviderReference: StateTransitionWitnessProviderReference;
+    runBatch: (publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch) => StateTransitionProverPublicOutput;
+    merge: (publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof) => StateTransitionProverPublicOutput;
+}
+export {};
+//# sourceMappingURL=StateTransitionProvable.d.ts.map

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

@@ -0,0 +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"}

package/dist/prover/statetransition/StateTransitionProvable.js

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

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

@@ -0,0 +1,39 @@
+import { Field } from "snarkyjs";
+import { ProvableHashList } from "../../utils/ProvableHashList";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { PlainZkProgram } from "@proto-kit/common";
+import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProof, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+interface StateTransitionProverExecutionState {
+    stateRoot: Field;
+    stateTransitionList: 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 {
+    readonly witnessProviderReference: StateTransitionWitnessProviderReference;
+    constructor(witnessProviderReference: StateTransitionWitnessProviderReference);
+    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;
+    /**
+     * Applies a single state transition to the given state
+     * and mutates it in place
+     */
+    applyTransition(state: StateTransitionProverExecutionState, transition: ProvableStateTransition, 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 {};
+//# sourceMappingURL=StateTransitionProver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProver.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,EAAuB,MAAM,UAAU,CAAC;AAOpE,OAAO,EAEL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAIxF,OAAO,EAEL,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EAChC,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,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;IAmDD,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;IAqCX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAiB7B,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,iCAAiC;CA6BrC"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -0,0 +1,157 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
+import { injectable } from "tsyringe";
+import { MerkleTreeUtils, RollupMerkleWitness, } from "../../utils/merkletree/RollupMerkleTree.js";
+import { DefaultProvableHashList, } from "../../utils/ProvableHashList";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { constants } from "../../Constants";
+import { provableMethod, } from "@proto-kit/common";
+import { StateTransitionProverPublicInput, StateTransitionProverPublicOutput, } from "./StateTransitionProvable";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+const errors = {
+    stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
+    stateTransitionsHashNotMatching: (step) => `State 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`,
+};
+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 {
+    constructor(
+    // Injected
+    witnessProviderReference) {
+        super();
+        this.witnessProviderReference = witnessProviderReference;
+    }
+    zkProgramFactory() {
+        const instance = this;
+        const program = Experimental.ZkProgram({
+            publicInput: StateTransitionProverPublicInput,
+            publicOutput: StateTransitionProverPublicOutput,
+            methods: {
+                proveBatch: {
+                    privateInputs: [StateTransitionProvableBatch],
+                    method(publicInput, batch) {
+                        return instance.runBatch(publicInput, batch);
+                    },
+                },
+                merge: {
+                    privateInputs: [
+                        StateTransitionSelfProofClass,
+                        StateTransitionSelfProofClass,
+                    ],
+                    method(publicInput, proof1, proof2) {
+                        return instance.merge(publicInput, proof1, proof2);
+                    },
+                },
+            },
+        });
+        const methods = {
+            proveBatch: program.proveBatch.bind(program),
+            merge: program.merge.bind(program),
+        };
+        const SelfProofClass = Experimental.ZkProgram.Proof(program);
+        return {
+            compile: program.compile.bind(program),
+            verify: program.verify.bind(program),
+            Proof: SelfProofClass,
+            methods,
+        };
+    }
+    get witnessProvider() {
+        const provider = this.witnessProviderReference.getWitnessProvider();
+        if (provider === undefined) {
+            throw errors.noWitnessProviderSet();
+        }
+        return provider;
+    }
+    /**
+     * Applies the state transitions to the current stateRoot
+     * and returns the new prover state
+     */
+    applyTransitions(stateRoot, stateTransitionCommitmentFrom, transitionBatch) {
+        const state = {
+            stateRoot,
+            stateTransitionList: new DefaultProvableHashList(ProvableStateTransition, stateTransitionCommitmentFrom),
+        };
+        const transitions = transitionBatch.batch;
+        for (let index = 0; index < constants.stateTransitionProverBatchSize; index++) {
+            this.applyTransition(state, transitions[index], index);
+        }
+        return state;
+    }
+    /**
+     * Applies a single state transition to the given state
+     * and mutates it in place
+     */
+    applyTransition(state, transition, index = 0) {
+        const treeWitness = Provable.witness(RollupMerkleWitness, () => this.witnessProvider.getWitness(transition.path));
+        Provable.log(`ST (${index})`, state.stateRoot, " value: ", transition.from.value);
+        const membershipValid = MerkleTreeUtils.checkMembership(treeWitness, state.stateRoot, transition.path, transition.from.value);
+        membershipValid
+            .or(transition.from.isSome.not())
+            .assertTrue(errors.merkleWitnessNotCorrect(index));
+        const newRoot = MerkleTreeUtils.computeRoot(treeWitness, transition.to.value);
+        state.stateRoot = Provable.if(transition.to.isSome, newRoot, state.stateRoot);
+        state.stateTransitionList.pushIf(transition, transition.path.equals(Field(0)).not());
+    }
+    /**
+     * Applies a whole batch of StateTransitions at once
+     */
+    runBatch(publicInput, batch) {
+        Provable.log(publicInput);
+        const result = this.applyTransitions(publicInput.stateRoot, publicInput.stateTransitionsHash, batch);
+        const output = new StateTransitionProverPublicOutput({
+            stateRoot: result.stateRoot,
+            stateTransitionsHash: result.stateTransitionList.commitment,
+        });
+        Provable.log(output);
+        return output;
+    }
+    merge(publicInput, proof1, proof2) {
+        proof1.verify();
+        proof2.verify();
+        // Check state
+        publicInput.stateRoot.assertEquals(proof1.publicInput.stateRoot, errors.stateRootNotMatching("publicInput.from -> proof1.from"));
+        proof1.publicOutput.stateRoot.assertEquals(proof2.publicInput.stateRoot, errors.stateRootNotMatching("proof1.to -> proof2.from"));
+        // 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"));
+        return new StateTransitionProverPublicInput({
+            stateRoot: proof2.publicOutput.stateRoot,
+            stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
+        });
+    }
+};
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StateTransitionProverPublicInput,
+        StateTransitionProvableBatch]),
+    __metadata("design:returntype", StateTransitionProverPublicOutput)
+], StateTransitionProver.prototype, "runBatch", null);
+__decorate([
+    provableMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StateTransitionProverPublicInput, Object, Object]),
+    __metadata("design:returntype", StateTransitionProverPublicOutput)
+], StateTransitionProver.prototype, "merge", null);
+StateTransitionProver = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [StateTransitionWitnessProviderReference])
+], StateTransitionProver);
+export { StateTransitionProver };

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

@@ -0,0 +1,16 @@
+import type { Field } from "snarkyjs";
+import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";
+/**
+ * Interface for providing merkle witnesses to the state-transition prover
+ */
+export interface StateTransitionWitnessProvider {
+    /**
+     * Provides the merkle witness corresponding to the given key
+     * @param key Merkle-tree key
+     */
+    getWitness: (key: Field) => RollupMerkleWitness;
+}
+export declare class NoOpStateTransitionWitnessProvider implements StateTransitionWitnessProvider {
+    getWitness(key: Field): RollupMerkleWitness;
+}
+//# sourceMappingURL=StateTransitionWitnessProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionWitnessProvider.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionWitnessProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,UAAU,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,mBAAmB,CAAC;CACjD;AAED,qBACa,kCACX,YAAW,8BAA8B;IAElC,UAAU,CAAC,GAAG,EAAE,KAAK,GAAG,mBAAmB;CAGnD"}

package/dist/prover/statetransition/StateTransitionWitnessProvider.js

@@ -0,0 +1,17 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "tsyringe";
+import { RollupMerkleWitness } from "../../utils/merkletree/RollupMerkleTree.js";
+let NoOpStateTransitionWitnessProvider = class NoOpStateTransitionWitnessProvider {
+    getWitness(key) {
+        return new RollupMerkleWitness({ path: [], isLeft: [] });
+    }
+};
+NoOpStateTransitionWitnessProvider = __decorate([
+    injectable()
+], NoOpStateTransitionWitnessProvider);
+export { NoOpStateTransitionWitnessProvider };

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

@@ -0,0 +1,7 @@
+import { StateTransitionWitnessProvider } from "./StateTransitionWitnessProvider";
+export declare class StateTransitionWitnessProviderReference {
+    private witnessProvider?;
+    setWitnessProvider(provider: StateTransitionWitnessProvider): void;
+    getWitnessProvider(): StateTransitionWitnessProvider | undefined;
+}
+//# sourceMappingURL=StateTransitionWitnessProviderReference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionWitnessProviderReference.d.ts","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionWitnessProviderReference.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAElF,qBAEa,uCAAuC;IAElD,OAAO,CAAC,eAAe,CAAC,CAAiC;IAElD,kBAAkB,CAAC,QAAQ,EAAE,8BAA8B;IAI3D,kBAAkB,IAAI,8BAA8B,GAAG,SAAS;CAGxE"}

package/dist/prover/statetransition/StateTransitionWitnessProviderReference.js

@@ -0,0 +1,20 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable, Lifecycle, scoped } from "tsyringe";
+let StateTransitionWitnessProviderReference = class StateTransitionWitnessProviderReference {
+    setWitnessProvider(provider) {
+        this.witnessProvider = provider;
+    }
+    getWitnessProvider() {
+        return this.witnessProvider;
+    }
+};
+StateTransitionWitnessProviderReference = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], StateTransitionWitnessProviderReference);
+export { StateTransitionWitnessProviderReference };