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

package/src/protocol/TransitioningProtocolModule.ts

@@ -0,0 +1,12 @@
+import { ProtocolModule } from "./ProtocolModule";
+
+/**
+ * TransitioningProtocolModule is a base interface that allows inheriting
+ * classes to use State and StateMap since it requires the implementation
+ * of a `name: string` property, which those classes need to function.
+ */
+export abstract class TransitioningProtocolModule<
+  Config,
+> extends ProtocolModule<Config> {
+  public name?: string;
+}

package/src/prover/accumulators/AppliedBatchHashList.ts

@@ -0,0 +1,32 @@
+import { Bool, Field } from "o1js";
+
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { NonMethods } from "../../utils/utils";
+import { AppliedStateTransitionBatch } from "../../model/AppliedStateTransitionBatch";
+
+/**
+ * A HashList for AppliedSTBatches, that in addition to the default
+ * functionality, checks that the pushed batches are not empty.
+ * If they are, the pushing is skipped.
+ * Note that if the batch has applied: false, the batch still has to be appended
+ * if it has STs inside
+ */
+export class AppliedBatchHashList extends DefaultProvableHashList<
+  NonMethods<AppliedStateTransitionBatch>
+> {
+  public constructor(commitment: Field = Field(0)) {
+    super(AppliedStateTransitionBatch, commitment);
+  }
+
+  private isNotEmpty(value: AppliedStateTransitionBatch): Bool {
+    return value.batchHash.equals(Field(0)).not();
+  }
+
+  public push(value: AppliedStateTransitionBatch) {
+    return super.pushIf(value, this.isNotEmpty(value));
+  }
+
+  public pushIf(value: AppliedStateTransitionBatch, condition: Bool) {
+    return super.pushIf(value, condition.and(this.isNotEmpty(value)));
+  }
+}

package/src/prover/accumulators/StateTransitionReductionList.ts

@@ -0,0 +1,92 @@
+import { Provable } from "o1js";
+
+import { ProvableOption } from "../../model/Option";
+import {
+  ProvableStateTransition,
+  StateTransition,
+} from "../../model/StateTransition";
+import { ProvableReductionHashList } from "../../utils/ProvableReductionHashList";
+
+export class StateTransitionReductionList extends ProvableReductionHashList<ProvableStateTransition> {
+  public push(value: ProvableStateTransition) {
+    this.pushWithMetadata(value);
+
+    return this;
+  }
+
+  public pushWithMetadata(value: ProvableStateTransition) {
+    return this.pushAndReduce(value, (previous: ProvableStateTransition) => {
+      const pathsMatch = previous.path.equals(value.path);
+
+      // Take the previous.from if the paths match, otherwise leave ST as is
+      const from = Provable.if(
+        pathsMatch,
+        ProvableOption,
+        previous.from,
+        value.from
+      );
+      // In case we have a layout like
+      // { from: 5, to: 10 }, { from: 10, to: none }
+      // we just take the first and discard the second
+      const to = Provable.if(
+        value.to.isSome.or(pathsMatch.not()),
+        ProvableOption,
+        value.to,
+        previous.to
+      );
+
+      const transition = new ProvableStateTransition({
+        path: value.path,
+        from: new ProvableOption(from),
+        to: new ProvableOption(to),
+      });
+
+      // Assert that connection is correct
+      previous.to.value
+        .equals(value.from.value)
+        .or(
+          previous.to.isSome
+            .not()
+            .and(previous.from.value.equals(value.from.value))
+        )
+        .or(pathsMatch.not())
+        .assertTrue();
+
+      return [transition, pathsMatch];
+    });
+  }
+
+  public toField() {
+    return this.commitment;
+  }
+}
+
+export function reduceStateTransitions(
+  transitions: StateTransition<unknown>[]
+): StateTransition<unknown>[] {
+  const reduced: StateTransition<unknown>[] = [];
+
+  transitions.forEach((st) => {
+    if (reduced.length === 0) {
+      reduced.push(st);
+      return;
+    }
+
+    const last = reduced.at(-1)!;
+    if (last.path.equals(st.path).toBoolean()) {
+      if (st.toValue.isSome.toBoolean()) {
+        reduced.pop();
+        reduced.push(
+          new StateTransition<unknown>(st.path, last.fromValue, st.toValue)
+        );
+      } else {
+        // Do nothing, because we discard that ST
+        // { from: 5, to: 10 }, { from: 10, to: none }
+        // cancel the 2nd
+      }
+    } else {
+      reduced.push(st);
+    }
+  });
+  return reduced;
+}

package/src/prover/accumulators/TransactionHashList.ts

@@ -0,0 +1,9 @@
+import { Field } from "o1js";
+
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+
+export class TransactionHashList extends DefaultProvableHashList<Field> {
+  public constructor(commitment: Field = Field(0)) {
+    super(Field, commitment);
+  }
+}

package/src/prover/accumulators/WitnessedRootHashList.ts

@@ -0,0 +1,61 @@
+import { Bool, Field, Struct } from "o1js";
+
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+
+/**
+ * Link between a certain applied batch stack and a given root hash that the
+ * stack has to evaluate to at that given point in time
+ */
+export class WitnessedRoot extends Struct({
+  appliedBatchListState: Field,
+  root: Field,
+}) {}
+
+export class WitnessedRootWitness extends Struct({
+  witnessedRoot: Field,
+  preimage: Field,
+}) {}
+
+/**
+ * Accumulator as of section "Intermediary state roots" of the STProver v2 spec
+ */
+
+export class WitnessedRootHashList extends DefaultProvableHashList<WitnessedRoot> {
+  public constructor(commitment: Field = Field(0)) {
+    super(WitnessedRoot, commitment);
+  }
+
+  /**
+   * To be used by the BlockProver or for tracing
+   *
+   * The main purpose of this method compared to the simple push methods
+   * is for deduplicating witnessed roots. We need to do this because the
+   * STProver can only witness once per batch, therefore if multiple witness
+   * points fall back to the same ST (because any batches in between were empty),
+   * this has to be detected and compensated for.
+   * This function does this using the preimage of the current list state.
+   *
+   * @param preimage The preimage to the **current** state of the list.
+   */
+  public witnessRoot(
+    witnessedRoot: WitnessedRoot,
+    preimage: Field,
+    condition: Bool
+  ) {
+    // Note, we don't have to validate the preimage here because of the following
+    // 1. If the sequencer doesn't provide the correct witness, the BlockProver's
+    //    equality check will fail
+    // 2. If the list is empty, no preimage exists, therefore condition (2) doesn't
+    //    apply, which is the same outcome when the sequencer provides an arbitrary witness
+    const preimageCheckList = new WitnessedRootHashList(preimage).push(
+      witnessedRoot
+    );
+
+    // Conditions:
+    // (1) don't append if witnessedRoot == finalizedRoot  -> Already covered in BlockProver
+    // (2) don't append if preimage.push({ finalizedRoot, pendingSTBatchesHash }) == this.commitment
+    const skipPush = preimageCheckList.commitment.equals(this.commitment);
+
+    return this.pushIf(witnessedRoot, condition.and(skipPush.not()));
+  }
+}

package/src/prover/block/BlockProvable.ts

@@ -1,45 +1,218 @@
-import { Field, Proof, Struct, UInt64 } from "snarkyjs";
+// eslint-disable-next-line max-classes-per-file
+import {
+  Bool,
+  DynamicProof,
+  Field,
+  Proof,
+  Signature,
+  Struct,
+  Void,
+} from "o1js";
+import { WithZkProgrammable, CompilableModule } from "@proto-kit/common";
 
 import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
-import { ZkProgrammable } from "@proto-kit/common";
-import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { NetworkState } from "../../model/network/NetworkState";
+import { TransactionHashList } from "../accumulators/TransactionHashList";
+import { MinaActionsHashList } from "../../utils/MinaPrefixedProvableHashList";
+import { AppliedBatchHashList } from "../accumulators/AppliedBatchHashList";
+import {
+  WitnessedRootHashList,
+  WitnessedRootWitness,
+} from "../accumulators/WitnessedRootHashList";
 
-export class BlockProverPublicInput extends Struct({
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
+import { RuntimeVerificationKeyAttestation } from "./accummulators/RuntimeVerificationKeyTree";
+
+// Should be equal to BlockProver.PublicInput
+export interface BlockProverState {
+  /**
+   * The current state root of the block prover
+   */
+  stateRoot: Field;
+
+  /**
+   * The current commitment of the transaction-list which
+   * will at the end equal the bundle hash
+   */
+  transactionList: TransactionHashList;
+
+  /**
+   * The network state which gives access to values such as blockHeight
+   * This value is the same for the whole batch (L2 block)
+   */
+  networkState: NetworkState;
+
+  /**
+   * The root of the merkle tree encoding all block hashes,
+   * see `BlockHashMerkleTree`
+   */
+  blockHashRoot: Field;
+
+  /**
+   * A variant of the transactionsHash that is never reset.
+   * Thought for usage in the sequence state mempool.
+   * In comparison, transactionsHash restarts at 0 for every new block
+   */
+  eternalTransactionsList: TransactionHashList;
+
+  pendingSTBatches: AppliedBatchHashList;
+
+  incomingMessages: MinaActionsHashList;
+
+  witnessedRoots: WitnessedRootHashList;
+
+  blockNumber: Field;
+}
+
+// TODO Sort and organize public inputs and outputs
+export class BlockProverStateCommitments extends Struct({
   transactionsHash: Field,
   stateRoot: Field,
+  // Commitment to the list of unprocessed (pending) batches of STs that need to be proven
+  pendingSTBatchesHash: Field,
+  witnessedRootsHash: Field,
   networkStateHash: Field,
-}) {}
+  blockHashRoot: Field,
+  eternalTransactionsHash: Field,
+  incomingMessagesHash: Field,
+  blockNumber: Field,
+}) {
+  public static fromBlockProverState(
+    state: BlockProverState
+  ): BlockProverStateCommitments {
+    return {
+      networkStateHash: state.networkState.hash(),
+      stateRoot: state.stateRoot,
+      blockNumber: state.blockNumber,
+      blockHashRoot: state.blockHashRoot,
+      pendingSTBatchesHash: state.pendingSTBatches.commitment,
+      transactionsHash: state.transactionList.commitment,
+      eternalTransactionsHash: state.eternalTransactionsList.commitment,
+      incomingMessagesHash: state.incomingMessages.commitment,
+      witnessedRootsHash: state.witnessedRoots.commitment,
+    };
+  }
+
+  public static toBlockProverState(
+    publicInput: BlockProverStateCommitments,
+    networkState: NetworkState
+  ): BlockProverState {
+    publicInput.networkStateHash.assertEquals(
+      networkState.hash(),
+      "ExecutionData Networkstate doesn't equal public input hash"
+    );
+
+    return {
+      networkState,
+      stateRoot: publicInput.stateRoot,
+      blockHashRoot: publicInput.blockHashRoot,
+      transactionList: new TransactionHashList(publicInput.transactionsHash),
+      eternalTransactionsList: new TransactionHashList(
+        publicInput.eternalTransactionsHash
+      ),
+      incomingMessages: new MinaActionsHashList(
+        publicInput.incomingMessagesHash
+      ),
+      pendingSTBatches: new AppliedBatchHashList(
+        publicInput.pendingSTBatchesHash
+      ),
+      witnessedRoots: new WitnessedRootHashList(publicInput.witnessedRootsHash),
+      blockNumber: publicInput.blockNumber,
+    };
+  }
+}
+
+export class BlockProverPublicInput extends BlockProverStateCommitments {}
 
 export class BlockProverPublicOutput extends Struct({
   transactionsHash: Field,
   stateRoot: Field,
-}) {}
+  pendingSTBatchesHash: Field,
+  witnessedRootsHash: Field,
+  networkStateHash: Field,
+  blockHashRoot: Field,
+  eternalTransactionsHash: Field,
+  incomingMessagesHash: Field,
+  closed: Bool,
+  blockNumber: Field,
+}) {
+  public equals(input: BlockProverPublicInput, closed: Bool): Bool {
+    const output2 = BlockProverPublicOutput.toFields({
+      ...input,
+      closed,
+    });
+    const output1 = BlockProverPublicOutput.toFields(this);
+    return output1
+      .map((value1, index) => value1.equals(output2[index]))
+      .reduce((a, b) => a.and(b));
+  }
+}
 
 export type BlockProverProof = Proof<
   BlockProverPublicInput,
   BlockProverPublicOutput
 >;
 
-export class BlockProverExecutionData extends Struct({
-  transaction: ProtocolTransaction,
+export class BlockProverTransactionArguments extends Struct({
+  transaction: RuntimeTransaction,
+  signature: Signature,
+  verificationKeyAttestation: RuntimeVerificationKeyAttestation,
+}) {}
+
+export class DynamicRuntimeProof extends DynamicProof<
+  Void,
+  MethodPublicOutput
+> {
+  static publicInputType = Void;
+
+  static publicOutputType = MethodPublicOutput;
+
+  // TODO this won't be 0 for proofs-as-args
+  static maxProofsVerified = 0 as const;
+}
+
+export class BlockProverSingleTransactionExecutionData extends Struct({
+  transaction: BlockProverTransactionArguments,
+  networkState: NetworkState,
+}) {}
+
+export class BlockProverMultiTransactionExecutionData extends Struct({
+  transaction1: BlockProverTransactionArguments,
+  transaction2: BlockProverTransactionArguments,
   networkState: NetworkState,
-  // accountstate
 }) {}
 
 export interface BlockProvable
-  extends ZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
+  extends WithZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput>,
+    CompilableModule {
   proveTransaction: (
     publicInput: BlockProverPublicInput,
-    stateProof: StateTransitionProof,
-    appProof: Proof<void, MethodPublicOutput>,
-    executionData: BlockProverExecutionData
-  ) => BlockProverPublicOutput;
+    runtimeProof: DynamicRuntimeProof,
+    executionData: BlockProverSingleTransactionExecutionData
+  ) => Promise<BlockProverPublicOutput>;
+
+  proveTransactions: (
+    publicInput: BlockProverPublicInput,
+    runtimeProof1: DynamicRuntimeProof,
+    runtimeProof2: DynamicRuntimeProof,
+    executionData: BlockProverMultiTransactionExecutionData
+  ) => Promise<BlockProverPublicOutput>;
+
+  proveBlock: (
+    publicInput: BlockProverPublicInput,
+    networkState: NetworkState,
+    blockWitness: BlockHashMerkleTreeWitness,
+    stateTransitionProof: StateTransitionProof,
+    deferSTs: Bool,
+    afterBlockRootWitness: WitnessedRootWitness,
+    transactionProof: BlockProverProof
+  ) => Promise<BlockProverPublicOutput>;
 
   merge: (
     publicInput: BlockProverPublicInput,
     proof1: BlockProverProof,
     proof2: BlockProverProof
-  ) => BlockProverPublicOutput;
+  ) => Promise<BlockProverPublicOutput>;
 }