@proto-kit/protocol 0.1.1-develop.164 → 0.1.1-develop.1661

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,MAAM,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3F,qBAAa,gCAAiC,SAAQ,qCAKpD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,iCAAkC,SAAQ,sCAKrD;CAAG;AAEL,MAAM,MAAM,oBAAoB,GAAG,KAAK,CACtC,gCAAgC,EAChC,iCAAiC,CAClC,CAAC;AAEF,MAAM,WAAW,uBACf,SAAQ,kBAAkB,CACtB,gCAAgC,EAChC,iCAAiC,CAClC,EACD,gBAAgB;IAClB,UAAU,EAAE,CACV,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB,EAC7B,mBAAmB,EAAE,gCAAgC,KAClD,OAAO,CAAC,iCAAiC,CAAC,CAAC;IAEhD,KAAK,EAAE,CACL,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,KACzB,OAAO,CAAC,iCAAiC,CAAC,CAAC;CACjD"}

package/dist/prover/statetransition/StateTransitionProvable.js

@@ -1,11 +1,16 @@
-import { Field, Struct } from "snarkyjs";
+import { Field, Struct } from "o1js";
 export class StateTransitionProverPublicInput extends Struct({
-    stateTransitionsHash: Field,
-    stateRoot: Field,
+    batchesHash: Field,
+    currentBatchStateHash: Field,
+    root: Field,
+    witnessedRootsHash: Field,
 }) {
 }
 export class StateTransitionProverPublicOutput extends Struct({
-    stateTransitionsHash: Field,
-    stateRoot: Field,
+    batchesHash: Field,
+    currentBatchStateHash: Field,
+    root: Field,
+    witnessedRootsHash: Field,
 }) {
 }
+//# sourceMappingURL=StateTransitionProvable.js.map

package/dist/prover/statetransition/StateTransitionProvable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProvable.js","sourceRoot":"","sources":["../../../src/prover/statetransition/StateTransitionProvable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAS,MAAM,EAAE,MAAM,MAAM,CAAC;AAS5C,MAAM,OAAO,gCAAiC,SAAQ,MAAM,CAAC;IAC3D,WAAW,EAAE,KAAK;IAClB,qBAAqB,EAAE,KAAK;IAC5B,IAAI,EAAE,KAAK;IACX,kBAAkB,EAAE,KAAK;CAC1B,CAAC;CAAG;AAEL,MAAM,OAAO,iCAAkC,SAAQ,MAAM,CAAC;IAC5D,WAAW,EAAE,KAAK;IAClB,qBAAqB,EAAE,KAAK;IAC5B,IAAI,EAAE,KAAK;IACX,kBAAkB,EAAE,KAAK;CAC1B,CAAC;CAAG"}

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

@@ -1,39 +1,52 @@
-import { Field } from "snarkyjs";
-import { ProvableHashList } from "../../utils/ProvableHashList";
+import { AreProofsEnabled, PlainZkProgram, ZkProgrammable, CompilableModule, type ArtifactRecord, type CompileRegistry, LinkedMerkleTreeWitness } from "@proto-kit/common";
+import { Field } from "o1js";
 import { ProvableStateTransition } from "../../model/StateTransition";
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
-import { PlainZkProgram } from "@proto-kit/common";
-import { StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProof, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
+import { MerkleWitnessBatch, StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import { StateTransitionProverType } from "../../protocol/Protocol";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
-import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import { WitnessedRootHashList } from "../accumulators/WitnessedRootHashList";
+import { AppliedBatchHashList } from "../accumulators/AppliedBatchHashList";
+import { AppliedStateTransitionBatchState } from "../../model/AppliedStateTransitionBatch";
+import { StateTransitionProof, StateTransitionProvable, StateTransitionProverPublicInput, StateTransitionProverPublicOutput } from "./StateTransitionProvable";
 interface StateTransitionProverExecutionState {
-    stateRoot: Field;
-    stateTransitionList: ProvableHashList<ProvableStateTransition>;
+    currentBatch: AppliedStateTransitionBatchState;
+    batchList: AppliedBatchHashList;
+    finalizedRoot: Field;
+    witnessedRoots: WitnessedRootHashList;
 }
 /**
  * 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();
+export declare class StateTransitionProverProgrammable extends ZkProgrammable<StateTransitionProverPublicInput, StateTransitionProverPublicOutput> {
+    private readonly stateTransitionProver;
+    constructor(stateTransitionProver: Pick<StateTransitionProver, "areProofsEnabled">);
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    zkProgramFactory(): PlainZkProgram<StateTransitionProverPublicInput, StateTransitionProverPublicOutput>[];
+    private transitionToTreeWrite;
     /**
      * Applies the state transitions to the current stateRoot
      * and returns the new prover state
      */
-    applyTransitions(stateRoot: Field, stateTransitionCommitmentFrom: Field, transitionBatch: StateTransitionProvableBatch): StateTransitionProverExecutionState;
+    applyTransitions(state: StateTransitionProverExecutionState, batch: StateTransitionProvableBatch, witnesses: MerkleWitnessBatch): StateTransitionProverExecutionState;
     /**
      * Applies a single state transition to the given state
      * and mutates it in place
      */
-    applyTransition(state: StateTransitionProverExecutionState, transition: ProvableStateTransition, index?: number): void;
+    applyTransition(currentBatch: AppliedStateTransitionBatchState, transition: ProvableStateTransition, witness: LinkedMerkleTreeWitness, index?: number): AppliedStateTransitionBatchState;
+    private applyTransitionToRoot;
     /**
      * Applies a whole batch of StateTransitions at once
      */
-    runBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch): StateTransitionProverPublicOutput;
-    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): StateTransitionProverPublicOutput;
+    proveBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch, witnesses: MerkleWitnessBatch, currentAppliedBatch: AppliedStateTransitionBatchState): Promise<StateTransitionProverPublicOutput>;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): Promise<StateTransitionProverPublicOutput>;
+}
+export declare class StateTransitionProver extends ProtocolModule implements StateTransitionProvable, StateTransitionProverType, CompilableModule {
+    zkProgrammable: StateTransitionProverProgrammable;
+    constructor();
+    compile(registry: CompileRegistry): Promise<void | ArtifactRecord>;
+    proveBatch(publicInput: StateTransitionProverPublicInput, batch: StateTransitionProvableBatch, witnesses: MerkleWitnessBatch, startingAppliedBatch: AppliedStateTransitionBatchState): Promise<StateTransitionProverPublicOutput>;
+    merge(publicInput: StateTransitionProverPublicInput, proof1: StateTransitionProof, proof2: StateTransitionProof): Promise<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;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;IAgCX;;OAEG;IAEI,QAAQ,CACb,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,GAClC,iCAAiC;IAe7B,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":"AAAA,OAAO,EACL,gBAAgB,EAChB,cAAc,EAEd,cAAc,EACd,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,eAAe,EAGpB,uBAAuB,EACxB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAkC,MAAM,MAAM,CAAC;AAI7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAE7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,gCAAgC,EAAE,MAAM,yCAAyC,CAAC;AAE3F,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AAUnC,UAAU,mCAAmC;IAC3C,YAAY,EAAE,gCAAgC,CAAC;IAC/C,SAAS,EAAE,oBAAoB,CAAC;IAChC,aAAa,EAAE,KAAK,CAAC;IACrB,cAAc,EAAE,qBAAqB,CAAC;CACvC;AAOD;;;GAGG;AACH,qBAAa,iCAAkC,SAAQ,cAAc,CACnE,gCAAgC,EAChC,iCAAiC,CAClC;IAEG,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBAArB,qBAAqB,EAAE,IAAI,CAC1C,qBAAqB,EACrB,kBAAkB,CACnB;IAKH,IAAW,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAE1D;IAEM,gBAAgB,IAAI,cAAc,CACvC,gCAAgC,EAChC,iCAAiC,CAClC,EAAE;IAmEH,OAAO,CAAC,qBAAqB;IAqB7B;;;OAGG;IACI,gBAAgB,CACrB,KAAK,EAAE,mCAAmC,EAC1C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB;IA2F/B;;;OAGG;IACI,eAAe,CACpB,YAAY,EAAE,gCAAgC,EAC9C,UAAU,EAAE,uBAAuB,EACnC,OAAO,EAAE,uBAAuB,EAChC,KAAK,SAAI;IAuBX,OAAO,CAAC,qBAAqB;IAgB7B;;OAEG;IAEU,UAAU,CACrB,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB,EAC7B,mBAAmB,EAAE,gCAAgC,GACpD,OAAO,CAAC,iCAAiC,CAAC;IAiChC,KAAK,CAChB,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAmE9C;AAED,qBACa,qBACX,SAAQ,cACR,YACE,uBAAuB,EACvB,yBAAyB,EACzB,gBAAgB;IAEX,cAAc,EAAE,iCAAiC,CAAC;;IAO5C,OAAO,CAClB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,IAAI,GAAG,cAAc,CAAC;IAI1B,UAAU,CACf,WAAW,EAAE,gCAAgC,EAC7C,KAAK,EAAE,4BAA4B,EACnC,SAAS,EAAE,kBAAkB,EAC7B,oBAAoB,EAAE,gCAAgC,GACrD,OAAO,CAAC,iCAAiC,CAAC;IAStC,KAAK,CACV,WAAW,EAAE,gCAAgC,EAC7C,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,iCAAiC,CAAC;CAG9C"}

package/dist/prover/statetransition/StateTransitionProver.js

@@ -7,46 +7,50 @@ 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);
 };
-import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
+import { provableMethod, ZkProgrammable, LinkedMerkleTreeCircuitOps, } from "@proto-kit/common";
+import { Field, Provable, SelfProof, ZkProgram } from "o1js";
 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 { ProvableStateTransition } from "../../model/StateTransition";
+import { MerkleWitnessBatch, StateTransitionProvableBatch, StateTransitionType, } from "../../model/StateTransitionProvableBatch";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
-import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { WitnessedRootHashList } from "../accumulators/WitnessedRootHashList";
+import { AppliedBatchHashList } from "../accumulators/AppliedBatchHashList";
+import { AppliedStateTransitionBatchState } from "../../model/AppliedStateTransitionBatch";
+import { StateTransitionProverPublicInput, StateTransitionProverPublicOutput, } from "./StateTransitionProvable";
 const errors = {
-    stateRootNotMatching: (step) => `StateRoots not matching ${step}`,
-    stateTransitionsHashNotMatching: (step) => `State transitions hash not matching ${step}`,
+    propertyNotMatching: (property, step) => `${property} 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) {
+export class StateTransitionProverProgrammable extends ZkProgrammable {
+    constructor(stateTransitionProver) {
         super();
-        this.witnessProviderReference = witnessProviderReference;
+        this.stateTransitionProver = stateTransitionProver;
+    }
+    get areProofsEnabled() {
+        return this.stateTransitionProver.areProofsEnabled;
     }
     zkProgramFactory() {
         const instance = this;
-        const program = Experimental.ZkProgram({
+        const program = ZkProgram({
+            name: "StateTransitionProver",
             publicInput: StateTransitionProverPublicInput,
             publicOutput: StateTransitionProverPublicOutput,
             methods: {
                 proveBatch: {
-                    privateInputs: [StateTransitionProvableBatch],
-                    method(publicInput, batch) {
-                        return instance.runBatch(publicInput, batch);
+                    privateInputs: [
+                        StateTransitionProvableBatch,
+                        MerkleWitnessBatch,
+                        AppliedStateTransitionBatchState,
+                    ],
+                    async method(publicInput, batch, witnesses, currentAppliedBatch) {
+                        return await instance.proveBatch(publicInput, batch, witnesses, currentAppliedBatch);
                     },
                 },
                 merge: {
@@ -54,8 +58,8 @@ let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
                         StateTransitionSelfProofClass,
                         StateTransitionSelfProofClass,
                     ],
-                    method(publicInput, proof1, proof2) {
-                        return instance.merge(publicInput, proof1, proof2);
+                    async method(publicInput, proof1, proof2) {
+                        return await instance.merge(publicInput, proof1, proof2);
                     },
                 },
             },
@@ -64,33 +68,78 @@ let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
             proveBatch: program.proveBatch.bind(program),
             merge: program.merge.bind(program),
         };
-        const SelfProofClass = Experimental.ZkProgram.Proof(program);
+        const SelfProofClass = ZkProgram.Proof(program);
+        return [
+            {
+                name: program.name,
+                compile: program.compile.bind(program),
+                verify: program.verify.bind(program),
+                analyzeMethods: program.analyzeMethods.bind(program),
+                Proof: SelfProofClass,
+                methods,
+            },
+        ];
+    }
+    transitionToTreeWrite(st, witness) {
+        // If from isSome isn't set, the user "ignored the previous value", i.e. we
+        // can assume the value in the witness is correct
+        const from = Provable.if(st.from.isSome, st.from.value, witness.leafCurrent.leaf.value);
+        // If the user doesn't want to write, we just carry over the from-value
+        const to = Provable.if(st.to.isSome, st.to.value, from);
         return {
-            compile: program.compile.bind(program),
-            verify: program.verify.bind(program),
-            Proof: SelfProofClass,
-            methods,
+            path: st.path,
+            from,
+            to,
         };
     }
-    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;
+    applyTransitions(state, batch, witnesses) {
+        const transitions = batch.batch;
         for (let index = 0; index < constants.stateTransitionProverBatchSize; index++) {
-            this.applyTransition(state, transitions[index], index);
+            const updatedBatchState = this.applyTransition(state.currentBatch, transitions[index].stateTransition, witnesses.witnesses[index], index);
+            // If the current batch is finished, we push it to the list
+            // and initialize the next
+            const { type, witnessRoot } = transitions[index];
+            const closing = type.isClosing();
+            const closingAndApply = type.type.equals(StateTransitionType.closeAndApply);
+            // Create the newBatch
+            // The root is based on if the previous batch will be applied or not
+            const base = Provable.if(closingAndApply, updatedBatchState.root, state.finalizedRoot);
+            const newBatchState = new AppliedStateTransitionBatchState({
+                batchHash: Field(0),
+                root: base,
+            });
+            const updatedBatch = {
+                applied: closingAndApply,
+                batchHash: updatedBatchState.batchHash,
+            };
+            state.batchList.pushIf(updatedBatch, closing);
+            state.finalizedRoot = Provable.if(closingAndApply, updatedBatchState.root, state.finalizedRoot);
+            // Add computed root to the witnessed root list if needed
+            witnessRoot
+                .implies(closing)
+                .assertTrue("Can only witness roots at closing batches");
+            state.witnessedRoots.pushIf({
+                root: state.finalizedRoot,
+                appliedBatchListState: state.batchList.commitment,
+            }, witnessRoot);
+            const isDummy = ProvableStateTransition.isDummy(transitions[index].stateTransition);
+            // Dummy STs cannot change any state, as to prevent any
+            // dummy-in-the-middle attacks. This is given if the type is nothing.
+            isDummy
+                .implies(type.isNothing())
+                .assertTrue("Dummies have to be of type 'nothing'");
+            isDummy
+                .implies(state.currentBatch.batchHash.equals(0))
+                .assertTrue("Dummies can only be placed on closed batchLists");
+            // Dummies don't close the batch, but we still want to ignore any
+            // updated batch, since we need to result to stay.
+            // This will break the pipeline if there is a dummy in the middle,
+            // but will only end up to invalid proofs (i.e. mismatched batches)
+            state.currentBatch = new AppliedStateTransitionBatchState(Provable.if(closing.or(isDummy), AppliedStateTransitionBatchState, newBatchState, updatedBatchState));
         }
         return state;
     }
@@ -98,57 +147,103 @@ 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) {
-        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 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());
+    applyTransition(currentBatch, transition, witness, index = 0) {
+        const impliedRoot = this.applyTransitionToRoot(transition, currentBatch.root, witness, index);
+        // Append ST to the current batch's ST-list
+        const stList = new DefaultProvableHashList(ProvableStateTransition, currentBatch.batchHash);
+        stList.push(transition);
+        // Update batch
+        return new AppliedStateTransitionBatchState({
+            batchHash: stList.commitment,
+            root: impliedRoot,
+        });
+    }
+    applyTransitionToRoot(transition, root, merkleWitness, index) {
+        const treeWrite = this.transitionToTreeWrite(transition, merkleWitness);
+        return LinkedMerkleTreeCircuitOps.applyTreeWrite(root, merkleWitness, treeWrite, index);
     }
     /**
      * Applies a whole batch of StateTransitions at once
      */
-    runBatch(publicInput, batch) {
-        const result = this.applyTransitions(publicInput.stateRoot, publicInput.stateTransitionsHash, batch);
-        const output = new StateTransitionProverPublicOutput({
-            stateRoot: result.stateRoot,
-            stateTransitionsHash: result.stateTransitionList.commitment,
+    async proveBatch(publicInput, batch, witnesses, currentAppliedBatch) {
+        currentAppliedBatch
+            .hashOrZero()
+            .assertEquals(publicInput.currentBatchStateHash, "Provided startingAppliedBatch not matching PI hash");
+        // Assert that either the currentAppliedBatch is somewhere intermediary
+        // or the root is the current "finalized" root
+        currentAppliedBatch.root
+            .equals(publicInput.root)
+            .or(publicInput.currentBatchStateHash.equals(0).not())
+            .assertTrue();
+        const state = {
+            batchList: new AppliedBatchHashList(publicInput.batchesHash),
+            currentBatch: currentAppliedBatch,
+            finalizedRoot: publicInput.root,
+            witnessedRoots: new WitnessedRootHashList(publicInput.witnessedRootsHash),
+        };
+        const result = this.applyTransitions(state, batch, witnesses);
+        return new StateTransitionProverPublicOutput({
+            batchesHash: result.batchList.commitment,
+            currentBatchStateHash: result.currentBatch.hashOrZero(),
+            root: result.finalizedRoot,
+            witnessedRootsHash: result.witnessedRoots.commitment,
         });
-        return output;
     }
-    merge(publicInput, proof1, proof2) {
+    async 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"));
+        // Check current batch hash
+        publicInput.currentBatchStateHash.assertEquals(proof1.publicInput.currentBatchStateHash, errors.propertyNotMatching("currentBatchStateHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.currentBatchStateHash.assertEquals(proof2.publicInput.currentBatchStateHash, errors.propertyNotMatching("currentBatchStateHash", "proof1.to -> proof2.from"));
+        // Check batches hash
+        publicInput.batchesHash.assertEquals(proof1.publicInput.batchesHash, errors.propertyNotMatching("batchesHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.batchesHash.assertEquals(proof2.publicInput.batchesHash, errors.propertyNotMatching("batchesHash", "proof1.to -> proof2.from"));
+        // Check root
+        publicInput.root.assertEquals(proof1.publicInput.root, errors.propertyNotMatching("root", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.root.assertEquals(proof2.publicInput.root, errors.propertyNotMatching("root", "proof1.to -> proof2.from"));
+        // Check root accumulator
+        publicInput.witnessedRootsHash.assertEquals(proof1.publicInput.witnessedRootsHash, errors.propertyNotMatching("witnessedRootsHash", "publicInput.from -> proof1.from"));
+        proof1.publicOutput.witnessedRootsHash.assertEquals(proof2.publicInput.witnessedRootsHash, errors.propertyNotMatching("witnessedRootsHash", "proof1.to -> proof2.from"));
         return new StateTransitionProverPublicInput({
-            stateRoot: proof2.publicOutput.stateRoot,
-            stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
+            currentBatchStateHash: proof2.publicOutput.currentBatchStateHash,
+            batchesHash: proof2.publicOutput.batchesHash,
+            root: proof2.publicOutput.root,
+            witnessedRootsHash: proof2.publicOutput.witnessedRootsHash,
         });
     }
-};
+}
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [StateTransitionProverPublicInput,
-        StateTransitionProvableBatch]),
-    __metadata("design:returntype", StateTransitionProverPublicOutput)
-], StateTransitionProver.prototype, "runBatch", null);
+        StateTransitionProvableBatch,
+        MerkleWitnessBatch,
+        AppliedStateTransitionBatchState]),
+    __metadata("design:returntype", Promise)
+], StateTransitionProverProgrammable.prototype, "proveBatch", null);
 __decorate([
     provableMethod(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [StateTransitionProverPublicInput, Object, Object]),
-    __metadata("design:returntype", StateTransitionProverPublicOutput)
-], StateTransitionProver.prototype, "merge", null);
+    __metadata("design:returntype", Promise)
+], StateTransitionProverProgrammable.prototype, "merge", null);
+export let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
+    constructor() {
+        super();
+        this.zkProgrammable = new StateTransitionProverProgrammable(this);
+    }
+    async compile(registry) {
+        return await this.zkProgrammable.compile(registry);
+    }
+    proveBatch(publicInput, batch, witnesses, startingAppliedBatch) {
+        return this.zkProgrammable.proveBatch(publicInput, batch, witnesses, startingAppliedBatch);
+    }
+    merge(publicInput, proof1, proof2) {
+        return this.zkProgrammable.merge(publicInput, proof1, proof2);
+    }
+};
 StateTransitionProver = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [StateTransitionWitnessProviderReference])
+    __metadata("design:paramtypes", [])
 ], StateTransitionProver);
-export { StateTransitionProver };
+//# sourceMappingURL=StateTransitionProver.js.map

package/dist/prover/statetransition/StateTransitionProver.js.map

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

package/dist/settlement/ContractModule.d.ts

@@ -0,0 +1,16 @@
+import { ArtifactRecord, type CompilableModule, CompileRegistry, ConfigurableModule, NoConfig, TypedClass } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+export type SmartContractClassFromInterface<Type> = typeof SmartContract & TypedClass<Type>;
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export declare abstract class ContractModule<ContractType, Config = NoConfig> extends ConfigurableModule<Config> implements CompilableModule {
+    abstract contractFactory(): SmartContractClassFromInterface<ContractType>;
+    abstract compile(registry: CompileRegistry): Promise<ArtifactRecord | undefined>;
+}
+//# sourceMappingURL=ContractModule.d.ts.map

package/dist/settlement/ContractModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractModule.d.ts","sourceRoot":"","sources":["../../src/settlement/ContractModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,gBAAgB,EACrB,eAAe,EACf,kBAAkB,EAClB,QAAQ,EACR,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAErC,MAAM,MAAM,+BAA+B,CAAC,IAAI,IAAI,OAAO,aAAa,GACtE,UAAU,CAAC,IAAI,CAAC,CAAC;AAEnB;;;;;;;GAOG;AACH,8BAAsB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,CAClE,SAAQ,kBAAkB,CAAC,MAAM,CACjC,YAAW,gBAAgB;aAEX,eAAe,IAAI,+BAA+B,CAAC,YAAY,CAAC;aAEhE,OAAO,CACrB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;CACvC"}

package/dist/settlement/ContractModule.js

@@ -0,0 +1,12 @@
+import { ConfigurableModule, } from "@proto-kit/common";
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export class ContractModule extends ConfigurableModule {
+}
+//# sourceMappingURL=ContractModule.js.map

package/dist/settlement/ContractModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractModule.js","sourceRoot":"","sources":["../../src/settlement/ContractModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,kBAAkB,GAGnB,MAAM,mBAAmB,CAAC;AAM3B;;;;;;;GAOG;AACH,MAAM,OAAgB,cACpB,SAAQ,kBAA0B;CAQnC"}

package/dist/settlement/SettlementContractModule.d.ts

@@ -0,0 +1,51 @@
+import { AreProofsEnabled, ChildContainerProvider, ModuleContainer, ModulesRecord, TypedClass } from "@proto-kit/common";
+import { Field, PublicKey, SmartContract } from "o1js";
+import { ProtocolEnvironment } from "../protocol/ProtocolEnvironment";
+import { ProtocolModule } from "../protocol/ProtocolModule";
+import { ContractModule } from "./ContractModule";
+import { DispatchContractProtocolModule } from "./contracts/DispatchContractProtocolModule";
+import { DispatchContractType } from "./contracts/DispatchSmartContract";
+import { SettlementContractConfig, SettlementContractProtocolModule } from "./contracts/SettlementContractProtocolModule";
+import { SettlementContractType } from "./contracts/SettlementSmartContract";
+import { BridgeContractType } from "./contracts/BridgeContract";
+import { BridgeContractConfig, BridgeContractProtocolModule } from "./contracts/BridgeContractProtocolModule";
+import { GetContracts } from "./modularity/types";
+export type SettlementModulesRecord = ModulesRecord<TypedClass<ContractModule<unknown, unknown>>>;
+export type MandatorySettlementModulesRecord = {
+    SettlementContract: TypedClass<ContractModule<SettlementContractType, SettlementContractConfig>>;
+    DispatchContract: TypedClass<ContractModule<DispatchContractType, unknown>>;
+    BridgeContract: TypedClass<ContractModule<BridgeContractType, BridgeContractConfig>>;
+};
+export declare class SettlementContractModule<SettlementModules extends SettlementModulesRecord & MandatorySettlementModulesRecord> extends ModuleContainer<SettlementModules> implements ProtocolModule<unknown> {
+    constructor(definition: SettlementModules);
+    static from<SettlementModules extends SettlementModulesRecord & MandatorySettlementModulesRecord>(modules: SettlementModules): TypedClass<SettlementContractModule<SettlementModules>>;
+    static mandatoryModules(): {
+        readonly SettlementContract: typeof SettlementContractProtocolModule;
+        readonly DispatchContract: typeof DispatchContractProtocolModule;
+        readonly BridgeContract: typeof BridgeContractProtocolModule;
+    };
+    static fromDefaults(): TypedClass<SettlementContractModule<{
+        readonly SettlementContract: typeof SettlementContractProtocolModule;
+        readonly DispatchContract: typeof DispatchContractProtocolModule;
+        readonly BridgeContract: typeof BridgeContractProtocolModule;
+    }>>;
+    static with<AdditionalModules extends SettlementModulesRecord>(additionalModules: AdditionalModules): TypedClass<SettlementContractModule<{
+        readonly SettlementContract: typeof SettlementContractProtocolModule;
+        readonly DispatchContract: typeof DispatchContractProtocolModule;
+        readonly BridgeContract: typeof BridgeContractProtocolModule;
+    } & AdditionalModules>>;
+    protocol?: ProtocolEnvironment;
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    create(childContainerProvider: ChildContainerProvider): void;
+    start(): Promise<void>;
+    getContractClasses(): GetContracts<SettlementModules>;
+    createContracts(addresses: {
+        settlement: PublicKey;
+        dispatch: PublicKey;
+    }): {
+        settlement: SettlementContractType & SmartContract;
+        dispatch: DispatchContractType & SmartContract;
+    };
+    createBridgeContract(address: PublicKey, tokenId?: Field): BridgeContractType & SmartContract;
+}
+//# sourceMappingURL=SettlementContractModule.d.ts.map

package/dist/settlement/SettlementContractModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettlementContractModule.d.ts","sourceRoot":"","sources":["../../src/settlement/SettlementContractModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,aAAa,EACb,UAAU,EAGX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAGvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,8BAA8B,EAAE,MAAM,4CAA4C,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EACL,wBAAwB,EACxB,gCAAgC,EACjC,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EACL,oBAAoB,EACpB,4BAA4B,EAC7B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,uBAAuB,GAAG,aAAa,CACjD,UAAU,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAC7C,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,kBAAkB,EAAE,UAAU,CAC5B,cAAc,CAAC,sBAAsB,EAAE,wBAAwB,CAAC,CACjE,CAAC;IACF,gBAAgB,EAAE,UAAU,CAAC,cAAc,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5E,cAAc,EAAE,UAAU,CACxB,cAAc,CAAC,kBAAkB,EAAE,oBAAoB,CAAC,CACzD,CAAC;CACH,CAAC;AAEF,qBACa,wBAAwB,CACjC,iBAAiB,SAAS,uBAAuB,GAC/C,gCAAgC,CAEpC,SAAQ,eAAe,CAAC,iBAAiB,CACzC,YAAW,cAAc,CAAC,OAAO,CAAC;gBAEf,UAAU,EAAE,iBAAiB;WAIlC,IAAI,CAChB,iBAAiB,SAAS,uBAAuB,GAC/C,gCAAgC,EAElC,OAAO,EAAE,iBAAiB,GACzB,UAAU,CAAC,wBAAwB,CAAC,iBAAiB,CAAC,CAAC;WAQ5C,gBAAgB;;;;;WAQhB,YAAY;;;;;WAMZ,IAAI,CAAC,iBAAiB,SAAS,uBAAuB,EAClE,iBAAiB,EAAE,iBAAiB;;;;;IAS/B,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAEtC,IAAW,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAE1D;IAGM,MAAM,CAAC,sBAAsB,EAAE,sBAAsB;IAI/C,KAAK;IAIX,kBAAkB,IAAI,YAAY,CAAC,iBAAiB,CAAC;IAUrD,eAAe,CAAC,SAAS,EAAE;QAChC,UAAU,EAAE,SAAS,CAAC;QACtB,QAAQ,EAAE,SAAS,CAAC;KACrB,GAAG;QACF,UAAU,EAAE,sBAAsB,GAAG,aAAa,CAAC;QACnD,QAAQ,EAAE,oBAAoB,GAAG,aAAa,CAAC;KAChD;IAYM,oBAAoB,CACzB,OAAO,EAAE,SAAS,EAClB,OAAO,CAAC,EAAE,KAAK,GACd,kBAAkB,GAAG,aAAa;CAKtC"}