@proto-kit/protocol 0.1.1-develop.191 → 0.1.1-develop.2024

package/dist/prover/statetransition/StateTransitionProver.js

@@ -7,48 +7,52 @@ 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 { provableMethod } 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 { constants } from "../../Constants";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { MerkleWitnessBatch, StateTransitionProvableBatch, StateTransitionType, } from "../../model/StateTransitionProvableBatch";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
+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";
-import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 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() {
-        // eslint-disable-next-line max-len
-        // eslint-disable-next-line @typescript-eslint/no-this-alias,consistent-this,unicorn/no-this-assignment
         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 {
+                            publicOutput: await instance.proveBatch(publicInput, batch, witnesses, currentAppliedBatch),
+                        };
                     },
                 },
                 merge: {
@@ -56,8 +60,10 @@ let StateTransitionProver = class StateTransitionProver extends ProtocolModule {
                         StateTransitionSelfProofClass,
                         StateTransitionSelfProofClass,
                     ],
-                    method(publicInput, proof1, proof2) {
-                        return instance.merge(publicInput, proof1, proof2);
+                    async method(publicInput, proof1, proof2) {
+                        return {
+                            publicOutput: await instance.merge(publicInput, proof1, proof2),
+                        };
                     },
                 },
             },
@@ -66,33 +72,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;
     }
@@ -100,56 +151,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);
+    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({
-            stateRoot: result.stateRoot,
-            stateTransitionsHash: result.stateTransitionList.commitment,
+            batchesHash: result.batchList.commitment,
+            currentBatchStateHash: result.currentBatch.hashOrZero(),
+            root: result.finalizedRoot,
+            witnessedRootsHash: result.witnessedRoots.commitment,
         });
     }
-    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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"}