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

package/src/prover/block/BlockProver.ts

@@ -1,7 +1,8 @@
 /* eslint-disable max-lines */
 import { Experimental, Field, type Proof, Provable, SelfProof } from "snarkyjs";
-import { inject, injectable } from "tsyringe";
+import { container, inject, injectable, injectAll } from "tsyringe";
 import {
+  AreProofsEnabled,
   PlainZkProgram,
   provableMethod,
   WithZkProgrammable,
@@ -25,6 +26,10 @@ import {
   BlockProverPublicInput,
   BlockProverPublicOutput,
 } from "./BlockProvable";
+import { ProvableStateTransition } from "../../model/StateTransition";
+import { ProvableTransactionHook } from "../../protocol/ProvableTransactionHook";
+import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethodExecutionContext";
+import { Protocol, ProtocolModulesRecord } from "../../protocol/Protocol";
 
 const errors = {
   stateProofNotStartingAtZero: () =>
@@ -58,28 +63,27 @@ export interface BlockProverState {
   networkStateHash: Field;
 }
 
-/**
- * BlockProver class, which aggregates a AppChainProof and
- * a StateTransitionProof into a single BlockProof, that can
- * then be merged to be committed to the base-layer contract
- */
-@injectable()
-export class BlockProver
-  extends ProtocolModule<BlockProverPublicInput, BlockProverPublicOutput>
-  implements BlockProvable
-{
+export class BlockProverProgrammable extends ZkProgrammable<
+  BlockProverPublicInput,
+  BlockProverPublicOutput
+> {
   public constructor(
-    @inject("StateTransitionProver")
-    private readonly stateTransitionProver: ZkProgrammable<
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    private readonly prover: BlockProver,
+    public readonly stateTransitionProver: ZkProgrammable<
       StateTransitionProverPublicInput,
       StateTransitionProverPublicOutput
     >,
-    @inject("Runtime")
-    private readonly runtime: WithZkProgrammable<void, MethodPublicOutput>
+    public readonly runtime: ZkProgrammable<undefined, MethodPublicOutput>,
+    private readonly blockModules: ProvableTransactionHook[]
   ) {
     super();
   }
 
+  public get appChain(): AreProofsEnabled | undefined {
+    return this.prover.appChain;
+  }
+
   /**
    * Applies and checks the two proofs and applies the corresponding state
    * changes to the given state
@@ -87,6 +91,7 @@ export class BlockProver
    * @param state The from-state of the BlockProver
    * @param stateTransitionProof
    * @param appProof
+   * @param executionData
    * @returns The new BlockProver-state to be used as public output
    */
   public applyTransaction(
@@ -96,8 +101,10 @@ export class BlockProver
       StateTransitionProverPublicOutput
     >,
     appProof: Proof<void, MethodPublicOutput>,
-    { transaction, networkState }: BlockProverExecutionData
+    executionData: BlockProverExecutionData
   ): BlockProverState {
+    const { transaction, networkState } = executionData;
+
     appProof.verify();
     stateTransitionProof.verify();
 
@@ -128,6 +135,9 @@ export class BlockProver
       stateTransitionProof.publicInput.stateRoot
     );
 
+    // Apply protocol state transitions
+    this.assertProtocolTransitions(stateTransitionProof, executionData);
+
     // Check transaction signature
     transaction
       .validateSignature()
@@ -169,6 +179,61 @@ export class BlockProver
     return stateTo;
   }
 
+  // eslint-disable-next-line no-warning-comments, max-len
+  // TODO How does this interact with the RuntimeMethodExecutionContext when executing runtimemethods?
+
+  public assertProtocolTransitions(
+    stateTransitionProof: Proof<
+      StateTransitionProverPublicInput,
+      StateTransitionProverPublicOutput
+    >,
+    executionData: BlockProverExecutionData
+  ) {
+    const executionContext = container.resolve(RuntimeMethodExecutionContext);
+    executionContext.clear();
+
+    // Setup context for potential calls to runtime methods.
+    // This way they can use this.transaction etc. while still having provable
+    // integrity between data
+    executionContext.setup({
+      transaction: RuntimeTransaction.fromProtocolTransaction(
+        executionData.transaction
+      ),
+
+      networkState: executionData.networkState,
+    });
+    executionContext.beforeMethod("", "", []);
+
+    this.blockModules.forEach((module) => {
+      module.onTransaction(executionData);
+    });
+
+    executionContext.afterMethod();
+
+    const { stateTransitions, status, statusMessage } =
+      executionContext.current().result;
+
+    status.assertTrue(statusMessage);
+
+    const transitions = stateTransitions.map((transition) =>
+      transition.toProvable()
+    );
+
+    const hashList = new DefaultProvableHashList(
+      ProvableStateTransition,
+      stateTransitionProof.publicInput.protocolTransitionsHash
+    );
+
+    transitions.forEach((transition) => {
+      hashList.push(transition);
+    });
+
+    stateTransitionProof.publicOutput.protocolTransitionsHash.assertEquals(
+      hashList.commitment,
+      "ProtocolTransitionsHash not matching the generated protocol transitions"
+    );
+  }
+
   @provableMethod()
   public proveTransaction(
     publicInput: BlockProverPublicInput,
@@ -239,12 +304,12 @@ export class BlockProver
     BlockProverPublicInput,
     BlockProverPublicOutput
   > {
-    const StateTransitionProofClass =
-      this.stateTransitionProver.zkProgram.Proof;
-    const RuntimeProofClass = this.runtime.zkProgrammable.zkProgram.Proof;
+    const { prover, stateTransitionProver, runtime } = this;
+    const StateTransitionProofClass = stateTransitionProver.zkProgram.Proof;
+    const RuntimeProofClass = runtime.zkProgram.Proof;
 
-    const proveTransaction = this.proveTransaction.bind(this);
-    const merge = this.merge.bind(this);
+    const proveTransaction = prover.proveTransaction.bind(prover);
+    const merge = prover.merge.bind(prover);
 
     const program = Experimental.ZkProgram({
       publicInput: BlockProverPublicInput,
@@ -305,3 +370,56 @@ export class BlockProver
     };
   }
 }
+
+/**
+ * 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
+ */
+@injectable()
+export class BlockProver extends ProtocolModule implements BlockProvable {
+  public zkProgrammable: BlockProverProgrammable;
+
+  public constructor(
+    @inject("StateTransitionProver")
+    public readonly stateTransitionProver: WithZkProgrammable<
+      StateTransitionProverPublicInput,
+      StateTransitionProverPublicOutput
+    >,
+    @inject("Runtime")
+    public readonly runtime: WithZkProgrammable<undefined, MethodPublicOutput>,
+    @injectAll("ProvableTransactionHook")
+    transactionHooks: ProvableTransactionHook[]
+  ) {
+    super();
+    this.zkProgrammable = new BlockProverProgrammable(
+      this,
+      stateTransitionProver.zkProgrammable,
+      runtime.zkProgrammable,
+      transactionHooks
+      // protocol.dependencyContainer.resolveAll("P rovableTransactionHook")
+    );
+  }
+
+  public merge(
+    publicInput: BlockProverPublicInput,
+    proof1: BlockProverProof,
+    proof2: BlockProverProof
+  ): BlockProverPublicOutput {
+    return this.zkProgrammable.merge(publicInput, proof1, proof2);
+  }
+
+  public proveTransaction(
+    publicInput: BlockProverPublicInput,
+    stateProof: StateTransitionProof,
+    appProof: Proof<void, MethodPublicOutput>,
+    executionData: BlockProverExecutionData
+  ): BlockProverPublicOutput {
+    return this.zkProgrammable.proveTransaction(
+      publicInput,
+      stateProof,
+      appProof,
+      executionData
+    );
+  }
+}

package/src/prover/statetransition/StateTransitionProvable.ts

@@ -1,5 +1,5 @@
 import { Field, Proof, Struct } from "snarkyjs";
-import { ZkProgrammable } from "@proto-kit/common";
+import { WithZkProgrammable, ZkProgrammable } from "@proto-kit/common";
 
 import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
 
@@ -7,11 +7,13 @@ import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnes
 
 export class StateTransitionProverPublicInput extends Struct({
   stateTransitionsHash: Field,
+  protocolTransitionsHash: Field,
   stateRoot: Field,
 }) {}
 
 export class StateTransitionProverPublicOutput extends Struct({
   stateTransitionsHash: Field,
+  protocolTransitionsHash: Field,
   stateRoot: Field,
 }) {}
 
@@ -21,7 +23,7 @@ export type StateTransitionProof = Proof<
 >;
 
 export interface StateTransitionProvable
-  extends ZkProgrammable<
+  extends WithZkProgrammable<
     StateTransitionProverPublicInput,
     StateTransitionProverPublicOutput
   > {

package/src/prover/statetransition/StateTransitionProver.ts

@@ -1,6 +1,12 @@
+/* eslint-disable max-lines */
 import { Experimental, Field, Provable, SelfProof } from "snarkyjs";
 import { injectable } from "tsyringe";
-import { PlainZkProgram, provableMethod } from "@proto-kit/common";
+import {
+  AreProofsEnabled,
+  PlainZkProgram,
+  provableMethod,
+  ZkProgrammable,
+} from "@proto-kit/common";
 
 import {
   MerkleTreeUtils,
@@ -11,7 +17,10 @@ import {
   ProvableHashList,
 } from "../../utils/ProvableHashList";
 import { ProvableStateTransition } from "../../model/StateTransition";
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
+import {
+  ProvableStateTransitionType,
+  StateTransitionProvableBatch,
+} from "../../model/StateTransitionProvableBatch";
 import { constants } from "../../Constants";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
 
@@ -30,6 +39,9 @@ const errors = {
   stateTransitionsHashNotMatching: (step: string) =>
     `State transitions hash not matching ${step}`,
 
+  protocolTransitionsHashNotMatching: (step: string) =>
+    `Protocol transitions hash not matching ${step}`,
+
   merkleWitnessNotCorrect: (index: number) =>
     `MerkleWitness not valid for StateTransition (${index})`,
 
@@ -44,6 +56,7 @@ const errors = {
 interface StateTransitionProverExecutionState {
   stateRoot: Field;
   stateTransitionList: ProvableHashList<ProvableStateTransition>;
+  protocolTransitionList: ProvableHashList<ProvableStateTransition>;
 }
 
 const StateTransitionSelfProofClass = SelfProof<
@@ -55,21 +68,22 @@ const StateTransitionSelfProofClass = SelfProof<
  * StateTransitionProver is the prover that proves the application of some state
  * transitions and checks and updates their merkle-tree entries
  */
-@injectable()
-export class StateTransitionProver
-  extends ProtocolModule<
-    StateTransitionProverPublicInput,
-    StateTransitionProverPublicOutput
-  >
-  implements StateTransitionProvable
-{
+export class StateTransitionProverProgrammable extends ZkProgrammable<
+  StateTransitionProverPublicInput,
+  StateTransitionProverPublicOutput
+> {
   public constructor(
-    // Injected
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    private readonly stateTransitionProver: StateTransitionProver,
     public readonly witnessProviderReference: StateTransitionWitnessProviderReference
   ) {
     super();
   }
 
+  public get appChain(): AreProofsEnabled | undefined {
+    return this.stateTransitionProver.appChain;
+  }
+
   public zkProgramFactory(): PlainZkProgram<
     StateTransitionProverPublicInput,
     StateTransitionProverPublicOutput
@@ -141,6 +155,7 @@ export class StateTransitionProver
   public applyTransitions(
     stateRoot: Field,
     stateTransitionCommitmentFrom: Field,
+    protocolTransitionCommitmentFrom: Field,
     transitionBatch: StateTransitionProvableBatch
   ): StateTransitionProverExecutionState {
     const state: StateTransitionProverExecutionState = {
@@ -150,15 +165,21 @@ export class StateTransitionProver
         ProvableStateTransition,
         stateTransitionCommitmentFrom
       ),
+
+      protocolTransitionList: new DefaultProvableHashList(
+        ProvableStateTransition,
+        protocolTransitionCommitmentFrom
+      ),
     };
 
     const transitions = transitionBatch.batch;
+    const types = transitionBatch.transitionTypes;
     for (
       let index = 0;
       index < constants.stateTransitionProverBatchSize;
       index++
     ) {
-      this.applyTransition(state, transitions[index], index);
+      this.applyTransition(state, transitions[index], types[index], index);
     }
 
     return state;
@@ -171,6 +192,7 @@ export class StateTransitionProver
   public applyTransition(
     state: StateTransitionProverExecutionState,
     transition: ProvableStateTransition,
+    type: ProvableStateTransitionType,
     index = 0
   ) {
     const treeWitness = Provable.witness(RollupMerkleWitness, () =>
@@ -187,19 +209,28 @@ export class StateTransitionProver
       .or(transition.from.isSome.not())
       .assertTrue(errors.merkleWitnessNotCorrect(index));
 
+    const t = Date.now();
     const newRoot = MerkleTreeUtils.computeRoot(
       treeWitness,
       transition.to.value
     );
+    Provable.log("Compute root took", Date.now() - t, "ms");
+
     state.stateRoot = Provable.if(
       transition.to.isSome,
       newRoot,
       state.stateRoot
     );
 
+    const isNotDummy = transition.path.equals(Field(0)).not();
+
     state.stateTransitionList.pushIf(
       transition,
-      transition.path.equals(Field(0)).not()
+      isNotDummy.and(type.isNormal())
+    );
+    state.protocolTransitionList.pushIf(
+      transition,
+      isNotDummy.and(type.isProtocol())
     );
   }
 
@@ -214,12 +245,14 @@ export class StateTransitionProver
     const result = this.applyTransitions(
       publicInput.stateRoot,
       publicInput.stateTransitionsHash,
+      publicInput.protocolTransitionsHash,
       batch
     );
 
     return new StateTransitionProverPublicOutput({
       stateRoot: result.stateRoot,
       stateTransitionsHash: result.stateTransitionList.commitment,
+      protocolTransitionsHash: result.protocolTransitionList.commitment,
     });
   }
 
@@ -252,9 +285,56 @@ export class StateTransitionProver
       errors.stateTransitionsHashNotMatching("proof1.to -> proof2.from")
     );
 
+    // Check Protocol ST list
+    publicInput.protocolTransitionsHash.assertEquals(
+      proof1.publicInput.protocolTransitionsHash,
+      errors.protocolTransitionsHashNotMatching(
+        "publicInput.from -> proof1.from"
+      )
+    );
+    proof1.publicOutput.protocolTransitionsHash.assertEquals(
+      proof2.publicInput.protocolTransitionsHash,
+      errors.protocolTransitionsHashNotMatching("proof1.to -> proof2.from")
+    );
+
     return new StateTransitionProverPublicInput({
       stateRoot: proof2.publicOutput.stateRoot,
       stateTransitionsHash: proof2.publicOutput.stateTransitionsHash,
+      protocolTransitionsHash: proof2.publicOutput.protocolTransitionsHash,
     });
   }
 }
+
+@injectable()
+export class StateTransitionProver
+  extends ProtocolModule
+  implements StateTransitionProvable
+{
+  public readonly zkProgrammable: StateTransitionProverProgrammable;
+
+  public constructor(
+    // Injected
+    public readonly witnessProviderReference: StateTransitionWitnessProviderReference
+  ) {
+    super();
+    this.zkProgrammable = new StateTransitionProverProgrammable(
+      this,
+      witnessProviderReference
+    );
+  }
+
+  public runBatch(
+    publicInput: StateTransitionProverPublicInput,
+    batch: StateTransitionProvableBatch
+  ): StateTransitionProverPublicOutput {
+    return this.zkProgrammable.runBatch(publicInput, batch);
+  }
+
+  public merge(
+    publicInput: StateTransitionProverPublicInput,
+    proof1: StateTransitionProof,
+    proof2: StateTransitionProof
+  ): StateTransitionProverPublicOutput {
+    return this.zkProgrammable.merge(publicInput, proof1, proof2);
+  }
+}

package/src/state/State.ts

@@ -0,0 +1,160 @@
+import { Mixin } from "ts-mixer";
+import { Bool, Field, Provable, type FlexibleProvablePure } from "snarkyjs";
+import { container } from "tsyringe";
+import { dummyValue } from "@proto-kit/common";
+
+import { Path } from "../model/Path";
+import { Option } from "../model/Option";
+import { StateTransition } from "../model/StateTransition";
+
+import { StateServiceProvider } from "./StateServiceProvider";
+import { RuntimeMethodExecutionContext } from "./context/RuntimeMethodExecutionContext";
+
+export class WithPath {
+  public path?: Field;
+
+  public hasPathOrFail(): asserts this is { path: Path } {
+    if (!this.path) {
+      throw new Error(
+        "Could not find 'path', did you forget to add '@state' to your state property?"
+      );
+    }
+  }
+}
+
+export class WithStateServiceProvider {
+  public stateServiceProvider?: StateServiceProvider;
+
+  public hasStateServiceOrFail(): asserts this is {
+    stateServiceProvider: StateServiceProvider;
+  } {
+    if (!this.stateServiceProvider) {
+      throw new Error(
+        "Could not find 'stateServiceProvider', did you forget to add '@state' to your state property?"
+      );
+    }
+  }
+}
+
+/**
+ * Utilities for runtime module state, such as get/set
+ */
+export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
+  /**
+   * Creates a new state wrapper for the provided value type.
+   *
+   * @param valueType - Type of value to be stored (e.g. UInt64, Struct, ...)
+   * @returns New state for the given value type.
+   */
+  public static from<Value>(valueType: FlexibleProvablePure<Value>) {
+    return new State<Value>(valueType);
+  }
+
+  public constructor(public valueType: FlexibleProvablePure<Value>) {
+    super();
+  }
+
+  private getState(): { value: Value; isSome: Bool } {
+    this.hasStateServiceOrFail();
+    this.hasPathOrFail();
+
+    const { path, stateServiceProvider, valueType } = this;
+
+    const { stateTransitions } = container
+      .resolve(RuntimeMethodExecutionContext)
+      .current().result;
+
+    // First try to find a match inside already created stateTransitions
+    const previousMutatingTransitions = stateTransitions.filter((transition) =>
+      transition.path.equals(path).and(transition.to.isSome).toBoolean()
+    );
+    const pmtLength = previousMutatingTransitions.length;
+
+    let value =
+      pmtLength > 0
+        ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          (previousMutatingTransitions[pmtLength - 1].to.value as Value)
+        : undefined;
+
+    if (value !== undefined) {
+      return { value, isSome: Bool(true) };
+    }
+
+    // If the value is still undefined, look it up in the stateService
+    const fields = stateServiceProvider.stateService.get(path);
+    if (fields) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      value = valueType.fromFields(fields) as Value;
+    }
+
+    if (value !== undefined) {
+      return { value, isSome: Bool(true) };
+    }
+    return { value: dummyValue(valueType), isSome: Bool(false) };
+  }
+
+  /**
+   * Provides an in-circuit witness for the current state representation,
+   * and constructs an Option out of it.
+   *
+   * @returns Optional value of the current state
+   */
+  private witnessState() {
+    // get the value from storage, or return a dummy value instead
+    const value = Provable.witness(this.valueType, () => this.getState().value);
+
+    // check if the value exists in the storage or not
+    const isSome = Provable.witness(Bool, () => this.getState().isSome);
+
+    return Option.from(isSome, value, this.valueType);
+  }
+
+  /**
+   * Retrieves the current state and creates a state transition
+   * anchoring the use of the current state value in the circuit.
+   *
+   * @returns Option representation of the current state.
+   */
+  public get(): Option<Value> {
+    const option = this.witnessState();
+
+    this.hasPathOrFail();
+
+    const stateTransition = StateTransition.from(this.path, option);
+
+    container
+      .resolve(RuntimeMethodExecutionContext)
+      .addStateTransition(stateTransition);
+
+    return option;
+  }
+
+  /**
+   * Sets a new state value by creating a state transition from
+   * the current value to the newly set value.
+   *
+   * The newly set value isn't available via state.get(), since the
+   * state transitions are not applied within the same circuit.
+   * You can however store and access your new value in
+   * a separate circuit variable.
+   *
+   * @param value - Value to be set as the current state
+   */
+  public set(value: Value) {
+    // link the transition to the current state
+    const fromOption = this.witnessState();
+    const toOption = Option.from(Bool(true), value, this.valueType);
+
+    this.hasPathOrFail();
+
+    const stateTransition = StateTransition.fromTo(
+      this.path,
+      fromOption,
+      toOption
+    );
+
+    container
+      .resolve(RuntimeMethodExecutionContext)
+      .addStateTransition(stateTransition);
+  }
+}

package/src/state/StateMap.ts

@@ -0,0 +1,74 @@
+import type { Field, FlexibleProvablePure } from "snarkyjs";
+import { Mixin } from "ts-mixer";
+
+import { Path } from "../model/Path";
+import { Option } from "../model/Option";
+
+import { State, WithStateServiceProvider, WithPath } from "./State";
+
+/**
+ * Map-like wrapper for state
+ */
+// eslint-disable-next-line new-cap
+export class StateMap<KeyType, ValueType> extends Mixin(
+  WithPath,
+  WithStateServiceProvider
+) {
+  /**
+   * Create a new state map with the given key and value types
+   *
+   * @param keyType - Type to be used as a key
+   * @param valueType - Type to be stored as a value
+   * @returns State map with provided key and value types.
+   */
+  public static from<KeyType, ValueType>(
+    keyType: FlexibleProvablePure<KeyType>,
+    valueType: FlexibleProvablePure<ValueType>
+  ): StateMap<KeyType, ValueType> {
+    return new StateMap<KeyType, ValueType>(keyType, valueType);
+  }
+
+  public constructor(
+    public keyType: FlexibleProvablePure<KeyType>,
+    public valueType: FlexibleProvablePure<ValueType>
+  ) {
+    super();
+  }
+
+  public getPath(key: KeyType): Field {
+    this.hasPathOrFail();
+    return Path.fromKey(this.path, this.keyType, key);
+  }
+
+  /**
+   * Obtains a value for the provided key in the current state map.
+   *
+   * @param key - Key to obtain the state for
+   * @returns Value for the provided key.
+   */
+  public get(key: KeyType): Option<ValueType> {
+    const state = State.from(this.valueType);
+    this.hasPathOrFail();
+    this.hasStateServiceOrFail();
+
+    state.path = this.getPath(key);
+    state.stateServiceProvider = this.stateServiceProvider;
+    return state.get();
+  }
+
+  /**
+   * Sets a value for the given key in the current state map.
+   *
+   * @param key - Key to store the value under
+   * @param value - Value to be stored under the given key
+   */
+  public set(key: KeyType, value: ValueType): void {
+    const state = State.from(this.valueType);
+    this.hasPathOrFail();
+    this.hasStateServiceOrFail();
+
+    state.path = Path.fromKey(this.path, this.keyType, key);
+    state.stateServiceProvider = this.stateServiceProvider;
+    state.set(value);
+  }
+}