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

package/src/prover/block/accummulators/BlockHashMerkleTree.ts

@@ -5,12 +5,20 @@ export class BlockHashMerkleTree extends createMerkleTree(40) {}
 export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {}
 
 export class BlockHashTreeEntry extends Struct({
-  blockHash: Field,
+  block: Struct({
+    index: Field,
+    transactionListHash: Field,
+  }),
   closed: Bool,
   // TODO We could add startingEternalTransactionsHash here to offer
-  // a more trivial connection to the sequence state
+  //  a more trivial connection to the sequence state
 }) {
   public hash(): Field {
-    return Poseidon.hash([this.blockHash, ...this.closed.toFields()]);
+    // Mirroring Block.hash()
+    const blockHash = Poseidon.hash([
+      this.block.index,
+      this.block.transactionListHash,
+    ]);
+    return Poseidon.hash([blockHash, ...this.closed.toFields()]);
   }
 }

package/src/prover/statetransition/StateTransitionProvable.ts

@@ -1,20 +1,24 @@
 import { Field, Proof, Struct } from "o1js";
 import { WithZkProgrammable, CompilableModule } from "@proto-kit/common";
 
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import {
+  MerkleWitnessBatch,
+  StateTransitionProvableBatch,
+} from "../../model/StateTransitionProvableBatch";
+import { AppliedStateTransitionBatchState } from "../../model/AppliedStateTransitionBatch";
 
 export class StateTransitionProverPublicInput extends Struct({
-  stateTransitionsHash: Field,
-  protocolTransitionsHash: Field,
-  stateRoot: Field,
-  protocolStateRoot: Field,
+  batchesHash: Field,
+  currentBatchStateHash: Field,
+  root: Field,
+  witnessedRootsHash: Field,
 }) {}
 
 export class StateTransitionProverPublicOutput extends Struct({
-  stateTransitionsHash: Field,
-  protocolTransitionsHash: Field,
-  stateRoot: Field,
-  protocolStateRoot: Field,
+  batchesHash: Field,
+  currentBatchStateHash: Field,
+  root: Field,
+  witnessedRootsHash: Field,
 }) {}
 
 export type StateTransitionProof = Proof<
@@ -28,9 +32,11 @@ export interface StateTransitionProvable
       StateTransitionProverPublicOutput
     >,
     CompilableModule {
-  runBatch: (
+  proveBatch: (
     publicInput: StateTransitionProverPublicInput,
-    batch: StateTransitionProvableBatch
+    batch: StateTransitionProvableBatch,
+    witnesses: MerkleWitnessBatch,
+    currentAppliedBatch: AppliedStateTransitionBatchState
   ) => Promise<StateTransitionProverPublicOutput>;
 
   merge: (

package/src/prover/statetransition/StateTransitionProver.ts

@@ -14,15 +14,16 @@ import { injectable } from "tsyringe";
 import { constants } from "../../Constants";
 import { ProvableStateTransition } from "../../model/StateTransition";
 import {
-  ProvableStateTransitionType,
+  MerkleWitnessBatch,
   StateTransitionProvableBatch,
+  StateTransitionType,
 } from "../../model/StateTransitionProvableBatch";
 import { StateTransitionProverType } from "../../protocol/Protocol";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
-import {
-  DefaultProvableHashList,
-  ProvableHashList,
-} from "../../utils/ProvableHashList";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { WitnessedRootHashList } from "../accumulators/WitnessedRootHashList";
+import { AppliedBatchHashList } from "../accumulators/AppliedBatchHashList";
+import { AppliedStateTransitionBatchState } from "../../model/AppliedStateTransitionBatch";
 
 import {
   StateTransitionProof,
@@ -35,31 +36,15 @@ const errors = {
   propertyNotMatching: (property: string, step: string) =>
     `${property} not matching ${step}`,
 
-  merkleWitnessNotCorrect: (
-    index: number,
-    type: ProvableStateTransitionType
-  ) => {
-    let s = `MerkleWitness not valid for StateTransition (${index}, type unknown)`;
-    Provable.asProver(() => {
-      s = s.replace(
-        "unknown",
-        type.isNormal().toBoolean() ? "normal" : "protocol"
-      );
-    });
-    return s;
-  },
-
-  noWitnessProviderSet: () =>
-    new Error(
-      "WitnessProvider not set, set it before you use StateTransitionProvider"
-    ),
+  merkleWitnessNotCorrect: (index: number) =>
+    `MerkleWitness not valid for StateTransition (${index})`,
 };
 
 interface StateTransitionProverExecutionState {
-  stateRoot: Field;
-  protocolStateRoot: Field;
-  stateTransitionList: ProvableHashList<ProvableStateTransition>;
-  protocolTransitionList: ProvableHashList<ProvableStateTransition>;
+  currentBatch: AppliedStateTransitionBatchState;
+  batchList: AppliedBatchHashList;
+  finalizedRoot: Field;
+  witnessedRoots: WitnessedRootHashList;
 }
 
 const StateTransitionSelfProofClass = SelfProof<
@@ -76,7 +61,10 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
   StateTransitionProverPublicOutput
 > {
   public constructor(
-    private readonly stateTransitionProver: StateTransitionProver
+    private readonly stateTransitionProver: Pick<
+      StateTransitionProver,
+      "areProofsEnabled"
+    >
   ) {
     super();
   }
@@ -97,14 +85,25 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
       publicOutput: StateTransitionProverPublicOutput,
 
       methods: {
-        runBatch: {
-          privateInputs: [StateTransitionProvableBatch],
+        proveBatch: {
+          privateInputs: [
+            StateTransitionProvableBatch,
+            MerkleWitnessBatch,
+            AppliedStateTransitionBatchState,
+          ],
 
           async method(
             publicInput: StateTransitionProverPublicInput,
-            batch: StateTransitionProvableBatch
+            batch: StateTransitionProvableBatch,
+            witnesses: MerkleWitnessBatch,
+            currentAppliedBatch: AppliedStateTransitionBatchState
           ) {
-            return await instance.runBatch(publicInput, batch);
+            return await instance.proveBatch(
+              publicInput,
+              batch,
+              witnesses,
+              currentAppliedBatch
+            );
           },
         },
 
@@ -126,7 +125,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
     });
 
     const methods = {
-      runBatch: program.runBatch.bind(program),
+      proveBatch: program.proveBatch.bind(program),
       merge: program.merge.bind(program),
     };
 
@@ -149,42 +148,94 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
    * and returns the new prover state
    */
   public applyTransitions(
-    stateRoot: Field,
-    protocolStateRoot: Field,
-    stateTransitionCommitmentFrom: Field,
-    protocolTransitionCommitmentFrom: Field,
-    transitionBatch: StateTransitionProvableBatch
-  ): StateTransitionProverExecutionState {
-    const state: StateTransitionProverExecutionState = {
-      stateRoot,
-      protocolStateRoot,
-
-      stateTransitionList: new DefaultProvableHashList(
-        ProvableStateTransition,
-        stateTransitionCommitmentFrom
-      ),
-
-      protocolTransitionList: new DefaultProvableHashList(
-        ProvableStateTransition,
-        protocolTransitionCommitmentFrom
-      ),
-    };
+    state: StateTransitionProverExecutionState,
+    batch: StateTransitionProvableBatch,
+    witnesses: MerkleWitnessBatch
+  ) {
+    const transitions = batch.batch;
 
-    const transitions = transitionBatch.batch;
-    const types = transitionBatch.transitionTypes;
-    const merkleWitness = transitionBatch.merkleWitnesses;
     for (
       let index = 0;
       index < constants.stateTransitionProverBatchSize;
       index++
     ) {
-      this.applyTransition(
-        state,
-        transitions[index],
-        types[index],
-        merkleWitness[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;
@@ -195,71 +246,91 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
    * and mutates it in place
    */
   public applyTransition(
-    state: StateTransitionProverExecutionState,
+    currentBatch: AppliedStateTransitionBatchState,
     transition: ProvableStateTransition,
-    type: ProvableStateTransitionType,
-    merkleWitness: RollupMerkleTreeWitness,
+    witness: RollupMerkleTreeWitness,
     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,
+    });
+  }
+
+  private applyTransitionToRoot(
+    transition: ProvableStateTransition,
+    root: Field,
+    merkleWitness: RollupMerkleTreeWitness,
+    index: number
+  ): Field {
     const membershipValid = merkleWitness.checkMembership(
-      state.stateRoot,
+      root,
       transition.path,
       transition.from.value
     );
 
     membershipValid
       .or(transition.from.isSome.not())
-      .assertTrue(errors.merkleWitnessNotCorrect(index, type));
+      .assertTrue(errors.merkleWitnessNotCorrect(index));
 
     const newRoot = merkleWitness.calculateRoot(transition.to.value);
 
-    state.stateRoot = Provable.if(
-      transition.to.isSome,
-      newRoot,
-      state.stateRoot
-    );
-
-    // Only update protocol state root if ST is also of type protocol
-    // Since protocol STs are all at the start of the batch, this works
-    state.protocolStateRoot = Provable.if(
-      transition.to.isSome.and(type.isProtocol()),
-      newRoot,
-      state.protocolStateRoot
-    );
-
-    const isNotDummy = transition.path.equals(Field(0)).not();
-
-    state.stateTransitionList.pushIf(
-      transition,
-      isNotDummy.and(type.isNormal())
-    );
-    state.protocolTransitionList.pushIf(
-      transition,
-      isNotDummy.and(type.isProtocol())
-    );
+    return Provable.if(transition.to.isSome, newRoot, root);
   }
 
   /**
    * Applies a whole batch of StateTransitions at once
    */
   @provableMethod()
-  public async runBatch(
+  public async proveBatch(
     publicInput: StateTransitionProverPublicInput,
-    batch: StateTransitionProvableBatch
+    batch: StateTransitionProvableBatch,
+    witnesses: MerkleWitnessBatch,
+    currentAppliedBatch: AppliedStateTransitionBatchState
   ): Promise<StateTransitionProverPublicOutput> {
-    const result = this.applyTransitions(
-      publicInput.stateRoot,
-      publicInput.protocolStateRoot,
-      publicInput.stateTransitionsHash,
-      publicInput.protocolTransitionsHash,
-      batch
-    );
+    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: StateTransitionProverExecutionState = {
+      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,
-      protocolTransitionsHash: result.protocolTransitionList.commitment,
-      protocolStateRoot: result.protocolStateRoot,
+      batchesHash: result.batchList.commitment,
+      currentBatchStateHash: result.currentBatch.hashOrZero(),
+      root: result.finalizedRoot,
+      witnessedRootsHash: result.witnessedRoots.commitment,
     });
   }
 
@@ -272,69 +343,66 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
     proof1.verify();
     proof2.verify();
 
-    // Check state
-    publicInput.stateRoot.assertEquals(
-      proof1.publicInput.stateRoot,
-      errors.propertyNotMatching("stateRoot", "publicInput.from -> proof1.from")
-    );
-    proof1.publicOutput.stateRoot.assertEquals(
-      proof2.publicInput.stateRoot,
-      errors.propertyNotMatching("stateRoot", "proof1.to -> proof2.from")
-    );
-
-    // Check ST list
-    publicInput.stateTransitionsHash.assertEquals(
-      proof1.publicInput.stateTransitionsHash,
+    // Check current batch hash
+    publicInput.currentBatchStateHash.assertEquals(
+      proof1.publicInput.currentBatchStateHash,
       errors.propertyNotMatching(
-        "stateTransitionsHash",
+        "currentBatchStateHash",
         "publicInput.from -> proof1.from"
       )
     );
-    proof1.publicOutput.stateTransitionsHash.assertEquals(
-      proof2.publicInput.stateTransitionsHash,
+    proof1.publicOutput.currentBatchStateHash.assertEquals(
+      proof2.publicInput.currentBatchStateHash,
       errors.propertyNotMatching(
-        "stateTransitionsHash",
+        "currentBatchStateHash",
         "proof1.to -> proof2.from"
       )
     );
 
-    // Check Protocol ST list
-    publicInput.protocolTransitionsHash.assertEquals(
-      proof1.publicInput.protocolTransitionsHash,
+    // Check batches hash
+    publicInput.batchesHash.assertEquals(
+      proof1.publicInput.batchesHash,
       errors.propertyNotMatching(
-        "protocolTransitionsHash",
+        "batchesHash",
         "publicInput.from -> proof1.from"
       )
     );
-    proof1.publicOutput.protocolTransitionsHash.assertEquals(
-      proof2.publicInput.protocolTransitionsHash,
-      errors.propertyNotMatching(
-        "protocolTransitionsHash",
-        "proof1.to -> proof2.from"
-      )
+    proof1.publicOutput.batchesHash.assertEquals(
+      proof2.publicInput.batchesHash,
+      errors.propertyNotMatching("batchesHash", "proof1.to -> proof2.from")
     );
 
-    // Check protocol state root
-    publicInput.protocolStateRoot.assertEquals(
-      proof1.publicInput.protocolStateRoot,
+    // 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(
-        "protocolStateRoot",
+        "witnessedRootsHash",
         "publicInput.from -> proof1.from"
       )
     );
-    proof1.publicOutput.protocolStateRoot.assertEquals(
-      proof2.publicInput.protocolStateRoot,
+    proof1.publicOutput.witnessedRootsHash.assertEquals(
+      proof2.publicInput.witnessedRootsHash,
       errors.propertyNotMatching(
-        "protocolStateRoot",
+        "witnessedRootsHash",
         "proof1.to -> proof2.from"
       )
     );
 
     return new StateTransitionProverPublicInput({
-      stateRoot: proof2.publicOutput.stateRoot,
-      stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
-      protocolTransitionsHash: proof2.publicOutput.protocolTransitionsHash,
-      protocolStateRoot: proof2.publicOutput.protocolStateRoot,
+      currentBatchStateHash: proof2.publicOutput.currentBatchStateHash,
+      batchesHash: proof2.publicOutput.batchesHash,
+      root: proof2.publicOutput.root,
+      witnessedRootsHash: proof2.publicOutput.witnessedRootsHash,
     });
   }
 }
@@ -360,11 +428,18 @@ export class StateTransitionProver
     return await this.zkProgrammable.compile(registry);
   }
 
-  public runBatch(
+  public proveBatch(
     publicInput: StateTransitionProverPublicInput,
-    batch: StateTransitionProvableBatch
+    batch: StateTransitionProvableBatch,
+    witnesses: MerkleWitnessBatch,
+    startingAppliedBatch: AppliedStateTransitionBatchState
   ): Promise<StateTransitionProverPublicOutput> {
-    return this.zkProgrammable.runBatch(publicInput, batch);
+    return this.zkProgrammable.proveBatch(
+      publicInput,
+      batch,
+      witnesses,
+      startingAppliedBatch
+    );
   }
 
   public merge(

package/src/settlement/contracts/SettlementSmartContract.ts

@@ -362,6 +362,10 @@ export abstract class SettlementSmartContractBase extends TokenContractV2 {
       Bool(true),
       "Supplied proof is not a closed BlockProof"
     );
+    blockProof.publicOutput.pendingSTBatchesHash.assertEquals(
+      Field(0),
+      "Supplied proof is has outstanding STs to be proven"
+    );
 
     // Execute onSettlementHooks for additional checks
     const stateRecord: SettlementStateRecord = {

package/src/state/assert/assert.ts

@@ -20,13 +20,16 @@ export function assert(condition: Bool, message?: string | (() => string)) {
 
   Provable.asProver(() => {
     if (!condition.toBoolean()) {
-      if (!executionContext.current().isSimulated) {
-        log.debug("Assertion failed: ", message);
-      }
       const messageString =
         message !== undefined && typeof message === "function"
           ? message()
           : message;
+
+      // If no isSimulated was set, we treat it as not simulated,
+      // therefore printing the log
+      if (!(executionContext.current().isSimulated ?? false)) {
+        log.debug("Assertion failed: ", messageString);
+      }
       executionContext.setStatusMessage(messageString, new Error().stack);
     }
   });

package/src/state/context/RuntimeMethodExecutionContext.ts

@@ -56,12 +56,17 @@ export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContex
 
   public input: RuntimeMethodExecutionData | undefined;
 
-  // The input corresponding to the current result
-  private lastInput: RuntimeMethodExecutionData | undefined;
+  private isSimulated: boolean = false;
 
-  public override result = new RuntimeProvableMethodExecutionResult();
+  // The inputs corresponding to the current result
+  private lastInputs:
+    | {
+        input: RuntimeMethodExecutionData | undefined;
+        isSimulated: boolean;
+      }
+    | undefined;
 
-  private isSimulated: boolean = false;
+  public override result = new RuntimeProvableMethodExecutionResult();
 
   private assertSetupCalled(): asserts this is {
     input: RuntimeMethodExecutionData;
@@ -152,7 +157,10 @@ export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContex
   public afterMethod() {
     super.afterMethod();
     if (this.isFinished) {
-      this.lastInput = this.input;
+      this.lastInputs = {
+        input: this.input,
+        isSimulated: this.isSimulated,
+      };
       // TODO: find out why input isnt set in TransactionFeeHook during assert
       // this.input = undefined;
       this.isSimulated = false;
@@ -167,8 +175,8 @@ export class RuntimeMethodExecutionContext extends ProvableMethodExecutionContex
     return {
       isFinished: this.isFinished,
       result: this.result,
-      input: this.lastInput,
-      isSimulated: this.isSimulated,
+      input: this.lastInputs?.input,
+      isSimulated: this.lastInputs?.isSimulated,
     };
   }
 }

package/src/utils/FieldOptions.ts

@@ -0,0 +1,13 @@
+import { Bool, Field, Provable, Struct } from "o1js";
+
+export class FieldOption extends Struct({
+  isSome: Bool,
+  value: Field,
+}) {
+  public static from(isSome: Bool, potentialValue: Field) {
+    return {
+      isSome,
+      value: Provable.if(isSome, potentialValue, Field(0)),
+    };
+  }
+}