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

package/src/prover/accumulators/BlockHashList.ts

@@ -0,0 +1,117 @@
+import { Field, Struct } from "o1js";
+
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import type { TransactionProverState } from "../transaction/TransactionProvable";
+import { NetworkState } from "../../model/network/NetworkState";
+
+export class BundlePreimage extends Struct({
+  preimage: Field,
+  fromStateTransitionsHash: Field,
+  fromWitnessedRootsHash: Field,
+}) {}
+
+export class FieldTransition extends Struct({
+  from: Field,
+  to: Field,
+}) {}
+
+/**
+ * A bundle represents an ordered list of transactions and their evaluated effects.
+ * Specifically, this includes beforeTransaction, runtime and afterTransaction evaluation,
+ * but not block hooks.
+ */
+export class Bundle extends Struct({
+  // Those are per-block trackers
+  networkStateHash: Field,
+  transactionsHash: Field,
+
+  // Those are non-linear trackers that we assert later in the blockprover
+  pendingSTBatchesHash: FieldTransition,
+  witnessedRootsHash: FieldTransition,
+}) {}
+
+/**
+ * This hash list collects an ordered list of Bundle instances.
+ * "Pushing" onto this list can mean either appending a new bundle or updating the
+ * bundle at the tip of this list, according to the following rules:
+ * The validated preimage (via checkLastBundleElement) is:
+ * - == commitment: A new bundle will be appended
+ * - something else: The preimage is the actual preimage, therefore as a operation,
+ *   the old one will be popped (silently) and the updates bundle will be pushed,
+ *   resulting in an semantic update of the tip.
+ */
+export class BundleHashList extends DefaultProvableHashList<Bundle> {
+  public constructor(
+    commitment: Field = Field(0),
+    // TODO Refactor this into preimage and "auxiliary batch information" - this is confusing
+    public preimage?: BundlePreimage
+  ) {
+    super(Bundle, commitment);
+  }
+
+  /** Verifies this list's preimage against the prover's state
+   * The main impact this function has is that it makes the preimage trusted
+   * i.e. we can safely use it to add to the bundle/open a new bundle
+   */
+  public checkLastBundleElement(
+    state: TransactionProverState,
+    networkState: NetworkState
+  ) {
+    const { preimage, fromWitnessedRootsHash, fromStateTransitionsHash } =
+      this.preimage!;
+
+    // Check and append to bundlelist
+    const lastElement = new Bundle({
+      networkStateHash: networkState.hash(),
+      transactionsHash: state.transactionList.commitment,
+      pendingSTBatchesHash: {
+        from: fromStateTransitionsHash,
+        to: state.pendingSTBatches.commitment,
+      },
+      witnessedRootsHash: {
+        from: fromWitnessedRootsHash,
+        to: state.witnessedRoots.commitment,
+      },
+    });
+
+    const newBundle = this.commitment.equals(preimage);
+    this.witnessTip(preimage, lastElement)
+      .or(newBundle)
+      .assertTrue("Last element not valid");
+
+    newBundle
+      .implies(state.transactionList.isEmpty())
+      .assertTrue("Transaction list not empty for new bundle");
+  }
+
+  /**
+   * This function pushes a new bundle onto this list or updates the bundle at
+   * the tip of this list, according to the rules of the preimage algorithms (see class docs)
+   */
+  public addToBundle(
+    state: TransactionProverState,
+    networkState: NetworkState
+  ) {
+    const { preimage, fromWitnessedRootsHash, fromStateTransitionsHash } =
+      this.preimage!;
+
+    const newElement = new Bundle({
+      networkStateHash: networkState.hash(),
+      transactionsHash: state.transactionList.commitment,
+      pendingSTBatchesHash: {
+        from: fromStateTransitionsHash,
+        to: state.pendingSTBatches.commitment,
+      },
+      witnessedRootsHash: {
+        from: fromWitnessedRootsHash,
+        to: state.witnessedRoots.commitment,
+      },
+    });
+
+    // We always overwrite here, the invariant is that the preimage is
+    // either the actual preimage in case of addition to the existing bundle
+    // or the current commitment in case of a new bundle
+    this.commitment = preimage;
+    this.push(newElement);
+  }
+}

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,62 @@
+import { Bool, Field, Provable, 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,
+}) {}
+
+/**
+ * Accumulator as of section "Intermediary state roots" of the STProver v2 spec
+ */
+
+export class WitnessedRootHashList extends DefaultProvableHashList<WitnessedRoot> {
+  public constructor(
+    commitment: Field = Field(0),
+    public preimage: 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.
+   */
+  public witnessRoot(witnessedRoot: WitnessedRoot, 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(this.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);
+
+    const fromCommitment = this.commitment;
+
+    const pushCondition = condition.and(skipPush.not());
+    this.pushIf(witnessedRoot, pushCondition);
+
+    this.preimage = Provable.if(pushCondition, fromCommitment, this.preimage);
+  }
+}

package/src/prover/block/BlockProvable.ts

@@ -1,45 +1,377 @@
-import { Field, Proof, Struct } from "snarkyjs";
-import { ZkProgrammable } from "@proto-kit/common";
+import { Bool, Field, Poseidon, Proof, Provable, Struct } from "o1js";
+import { CompilableModule, WithZkProgrammable } from "@proto-kit/common";
 
 import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
-import { MethodPublicOutput } from "../../model/MethodPublicOutput";
-import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
 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";
+import { TransactionProof } from "../transaction/TransactionProvable";
+import { BundleHashList, FieldTransition } from "../accumulators/BlockHashList";
+import { NonMethods } from "../../utils/utils";
 
-export class BlockProverPublicInput extends Struct({
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
+
+export const BLOCK_ARGUMENT_BATCH_SIZE = 4;
+
+export class BlockArguments extends Struct({
+  afterBlockRootWitness: WitnessedRootWitness,
   transactionsHash: Field,
-  stateRoot: Field,
-  networkStateHash: Field,
+  pendingSTBatchesHash: FieldTransition,
+  witnessedRootsHash: FieldTransition,
+  isDummy: Bool,
+}) {
+  public static noop(
+    state: NonMethods<Omit<BlockProverState, "blockWitness">>,
+    stateRoot: Field
+  ) {
+    return new BlockArguments({
+      afterBlockRootWitness: {
+        witnessedRoot: stateRoot,
+      },
+      transactionsHash: Field(0),
+      pendingSTBatchesHash: {
+        from: state.pendingSTBatches.commitment,
+        to: state.pendingSTBatches.commitment,
+      },
+      witnessedRootsHash: {
+        from: state.witnessedRoots.commitment,
+        to: state.witnessedRoots.commitment,
+      },
+      isDummy: Bool(true),
+    });
+  }
+}
+
+export class BlockArgumentsBatch extends Struct({
+  batch: Provable.Array(BlockArguments, BLOCK_ARGUMENT_BATCH_SIZE),
 }) {}
 
-export class BlockProverPublicOutput extends Struct({
-  transactionsHash: Field,
+const BlockProverStateBaseFields = {
+  eternalTransactionsHash: Field,
+  incomingMessagesHash: Field,
   stateRoot: Field,
-}) {}
+  blockHashRoot: Field,
+  blockNumber: Field,
+  networkStateHash: Field,
+};
 
-export type BlockProverProof = Proof<
-  BlockProverPublicInput,
-  BlockProverPublicOutput
->;
+export class BlockProverPublicInput extends Struct({
+  // Tracker of the current block prover state
+  proverStateRemainder: Field,
+  ...BlockProverStateBaseFields,
+}) {
+  public equals(input: BlockProverPublicInput): Bool {
+    const output2 = BlockProverPublicInput.toFields(input);
+    const output1 = BlockProverPublicInput.toFields(this);
+    return output1
+      .map((value1, index) => value1.equals(output2[index]))
+      .reduce((a, b) => a.and(b));
+  }
 
-export class BlockProverExecutionData extends Struct({
-  transaction: ProtocolTransaction,
-  networkState: NetworkState,
-  // accountstate
-}) {}
+  public clone() {
+    return new BlockProverPublicInput(
+      BlockProverPublicInput.fromFields(BlockProverPublicInput.toFields(this))
+    );
+  }
+}
+
+export const BlockProverStateCommitments = {
+  remainders: {
+    // Commitment to the list of unprocessed (pending) batches of STs that need to be proven
+    pendingSTBatchesHash: Field,
+    witnessedRootsHash: Field,
+    bundlesHash: Field,
+    witnessedRootsPreimage: Field,
+  },
+  ...BlockProverStateBaseFields,
+};
+
+export class BlockProverStateInput extends Struct(BlockProverStateCommitments) {
+  public hash() {
+    return Poseidon.hash(BlockProverStateInput.toFields(this));
+  }
+
+  public static fromPublicInput(input: BlockProverPublicInput) {
+    return new BlockProverStateInput({
+      remainders: {
+        bundlesHash: Field(0),
+        pendingSTBatchesHash: Field(0),
+        witnessedRootsHash: Field(0),
+        witnessedRootsPreimage: Field(0),
+      },
+      eternalTransactionsHash: input.eternalTransactionsHash,
+      incomingMessagesHash: input.incomingMessagesHash,
+      stateRoot: input.stateRoot,
+      blockHashRoot: input.blockHashRoot,
+      blockNumber: input.blockNumber,
+      networkStateHash: input.networkStateHash,
+    });
+  }
+
+  public finalize(condition: Bool) {
+    condition
+      .implies(
+        this.remainders.bundlesHash
+          .equals(0)
+          .and(this.remainders.pendingSTBatchesHash.equals(0))
+          .and(this.remainders.witnessedRootsHash.equals(0))
+      )
+      .assertTrue("Remainers not fully removed");
+
+    return new BlockProverPublicInput({
+      proverStateRemainder: Field(0),
+      eternalTransactionsHash: this.eternalTransactionsHash,
+      incomingMessagesHash: this.incomingMessagesHash,
+      stateRoot: this.stateRoot,
+      blockHashRoot: this.blockHashRoot,
+      blockNumber: this.blockNumber,
+      networkStateHash: this.networkStateHash,
+    });
+  }
+}
+
+export class BlockProverPublicOutput extends BlockProverPublicInput {}
+
+export class BlockProverState {
+  /**
+   * The network state which gives access to values such as blockHeight
+   * This value is the same for the whole batch (L2 block)
+   */
+  bundleList: BundleHashList;
+
+  /**
+   * 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;
+
+  /**
+   * The current state root of the block prover
+   */
+  stateRoot: Field;
+
+  /**
+   * The root of the merkle tree encoding all block hashes,
+   * see `BlockHashMerkleTree`
+   */
+  blockHashRoot: Field;
+
+  blockNumber: Field;
+
+  blockWitness: BlockHashMerkleTreeWitness;
+
+  networkState: NetworkState;
+
+  constructor(args: {
+    networkState: NetworkState;
+    eternalTransactionsList: TransactionHashList;
+    pendingSTBatches: AppliedBatchHashList;
+    stateRoot: Field;
+    blockHashRoot: Field;
+    blockNumber: Field;
+    bundleList: BundleHashList;
+    blockWitness: BlockHashMerkleTreeWitness;
+    witnessedRoots: WitnessedRootHashList;
+    incomingMessages: MinaActionsHashList;
+  }) {
+    this.bundleList = args.bundleList;
+    this.eternalTransactionsList = args.eternalTransactionsList;
+    this.pendingSTBatches = args.pendingSTBatches;
+    this.stateRoot = args.stateRoot;
+    this.blockHashRoot = args.blockHashRoot;
+    this.blockNumber = args.blockNumber;
+    this.networkState = args.networkState;
+    this.blockWitness = args.blockWitness;
+    this.witnessedRoots = args.witnessedRoots;
+    this.incomingMessages = args.incomingMessages;
+  }
+
+  public toCommitments(): BlockProverStateInput {
+    return new BlockProverStateInput({
+      remainders: {
+        bundlesHash: this.bundleList.commitment,
+        pendingSTBatchesHash: this.pendingSTBatches.commitment,
+        witnessedRootsHash: this.witnessedRoots.commitment,
+        witnessedRootsPreimage: this.witnessedRoots.preimage,
+      },
+      eternalTransactionsHash: this.eternalTransactionsList.commitment,
+      incomingMessagesHash: this.incomingMessages.commitment,
+      stateRoot: this.stateRoot,
+      blockHashRoot: this.blockHashRoot,
+      blockNumber: this.blockNumber,
+      networkStateHash: this.networkState.hash(),
+    });
+  }
+
+  public static blockProverFromCommitments(
+    stateInput: NonMethods<BlockProverStateInput>,
+    networkState: NetworkState,
+    blockWitness: BlockHashMerkleTreeWitness
+  ): BlockProverState {
+    return new BlockProverState({
+      bundleList: new BundleHashList(stateInput.remainders.bundlesHash),
+      eternalTransactionsList: new TransactionHashList(
+        stateInput.eternalTransactionsHash
+      ),
+      incomingMessages: new MinaActionsHashList(
+        stateInput.incomingMessagesHash
+      ),
+      pendingSTBatches: new AppliedBatchHashList(
+        stateInput.remainders.pendingSTBatchesHash
+      ),
+      witnessedRoots: new WitnessedRootHashList(
+        stateInput.remainders.witnessedRootsHash,
+        stateInput.remainders.witnessedRootsPreimage
+      ),
+      stateRoot: stateInput.stateRoot,
+      blockHashRoot: stateInput.blockHashRoot,
+      blockNumber: stateInput.blockNumber,
+      networkState,
+      blockWitness,
+    });
+  }
+
+  public copy() {
+    return BlockProverState.fromFields(this.toFields());
+  }
+
+  public toFields() {
+    return [
+      this.bundleList.commitment,
+      this.eternalTransactionsList.commitment,
+      this.pendingSTBatches.commitment,
+      this.incomingMessages.commitment,
+      this.witnessedRoots.commitment,
+      this.witnessedRoots.preimage,
+      this.stateRoot,
+      this.blockHashRoot,
+      this.blockNumber,
+      ...NetworkState.toFields(this.networkState),
+      ...BlockHashMerkleTreeWitness.toFields(this.blockWitness),
+    ];
+  }
+
+  // TODO Unit test
+  public static fromFields(fields: Field[]) {
+    return new BlockProverState({
+      bundleList: new BundleHashList(fields[0]),
+      eternalTransactionsList: new TransactionHashList(fields[1]),
+      pendingSTBatches: new AppliedBatchHashList(fields[2]),
+      incomingMessages: new MinaActionsHashList(fields[3]),
+      witnessedRoots: new WitnessedRootHashList(fields[4], fields[5]),
+      stateRoot: fields[6],
+      blockHashRoot: fields[7],
+      blockNumber: fields[8],
+      networkState: new NetworkState(NetworkState.fromFields(fields.slice(9))),
+      blockWitness: new BlockHashMerkleTreeWitness(
+        BlockHashMerkleTreeWitness.fromFields(
+          fields.slice(9 + NetworkState.sizeInFields())
+        )
+      ),
+    });
+  }
+
+  public static choose(
+    condition: Bool,
+    a: BlockProverState,
+    b: BlockProverState
+  ) {
+    return new BlockProverState({
+      bundleList: new BundleHashList(
+        Provable.if(condition, a.bundleList.commitment, b.bundleList.commitment)
+      ),
+      eternalTransactionsList: new TransactionHashList(
+        Provable.if(
+          condition,
+          a.eternalTransactionsList.commitment,
+          b.eternalTransactionsList.commitment
+        )
+      ),
+      pendingSTBatches: new AppliedBatchHashList(
+        Provable.if(
+          condition,
+          a.pendingSTBatches.commitment,
+          b.pendingSTBatches.commitment
+        )
+      ),
+      incomingMessages: new MinaActionsHashList(
+        Provable.if(
+          condition,
+          a.incomingMessages.commitment,
+          b.incomingMessages.commitment
+        )
+      ),
+      witnessedRoots: new WitnessedRootHashList(
+        Provable.if(
+          condition,
+          a.witnessedRoots.commitment,
+          b.witnessedRoots.commitment
+        ),
+        Provable.if(
+          condition,
+          a.witnessedRoots.preimage,
+          b.witnessedRoots.preimage
+        )
+      ),
+      stateRoot: Provable.if(condition, a.stateRoot, b.stateRoot),
+      blockHashRoot: Provable.if(condition, a.blockHashRoot, b.blockHashRoot),
+      blockWitness: new BlockHashMerkleTreeWitness(
+        Provable.if(
+          condition,
+          BlockHashMerkleTreeWitness,
+          a.blockWitness,
+          b.blockWitness
+        )
+      ),
+      blockNumber: Provable.if(condition, a.blockNumber, b.blockNumber),
+      networkState: new NetworkState(
+        Provable.if(condition, NetworkState, a.networkState, b.networkState)
+      ),
+    });
+  }
+}
+
+export type BlockProof = Proof<BlockProverPublicInput, BlockProverPublicOutput>;
 
 export interface BlockProvable
-  extends ZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
-  proveTransaction: (
+  extends WithZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput>,
+    CompilableModule {
+  proveBlockBatchNoProofs: (
+    publicInput: BlockProverPublicInput,
+    stateWitness: BlockProverStateInput,
+    networkState: NetworkState,
+    blockWitness: BlockHashMerkleTreeWitness,
+    batch: BlockArgumentsBatch,
+    finalize: Bool
+  ) => Promise<BlockProverPublicOutput>;
+
+  proveBlockBatchWithProofs: (
     publicInput: BlockProverPublicInput,
-    stateProof: StateTransitionProof,
-    appProof: Proof<void, MethodPublicOutput>,
-    executionData: BlockProverExecutionData
-  ) => BlockProverPublicOutput;
+    stateWitness: BlockProverStateInput,
+    networkState: NetworkState,
+    blockWitness: BlockHashMerkleTreeWitness,
+    batch: BlockArgumentsBatch,
+    deferSTProof: Bool,
+    deferTransactionProof: Bool,
+    stateTransitionProof: StateTransitionProof,
+    transactionProof: TransactionProof
+  ) => Promise<BlockProverPublicOutput>;
 
   merge: (
     publicInput: BlockProverPublicInput,
-    proof1: BlockProverProof,
-    proof2: BlockProverProof
-  ) => BlockProverPublicOutput;
+    proof1: BlockProof,
+    proof2: BlockProof
+  ) => Promise<BlockProverPublicOutput>;
 }