@proto-kit/protocol 0.1.1-develop.1086

package/src/protocol/ProtocolModule.ts

@@ -0,0 +1,27 @@
+import {
+  AreProofsEnabled,
+  ChildContainerProvider,
+  ConfigurableModule,
+  NoConfig,
+  noop,
+} from "@proto-kit/common";
+
+import { ProtocolEnvironment } from "./ProtocolEnvironment";
+
+export abstract class ProtocolModule<
+  Config = NoConfig,
+> extends ConfigurableModule<Config> {
+  public protocol?: ProtocolEnvironment;
+
+  public get appChain(): AreProofsEnabled | undefined {
+    return this.protocol?.getAreProofsEnabled();
+  }
+
+  public create(childContainerProvider: ChildContainerProvider): void {
+    noop();
+  }
+
+  public async start() {
+    noop();
+  }
+}

package/src/protocol/ProvableBlockHook.ts

@@ -0,0 +1,19 @@
+import type { BlockProverState } from "../prover/block/BlockProver";
+import { NetworkState } from "../model/network/NetworkState";
+
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+
+// Purpose is to build transition from -> to network state
+export abstract class ProvableBlockHook<
+  Config,
+> extends TransitioningProtocolModule<Config> {
+  public abstract beforeBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): Promise<NetworkState>;
+
+  public abstract afterBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): Promise<NetworkState>;
+}

package/src/protocol/ProvableTransactionHook.ts

@@ -0,0 +1,13 @@
+import { NoConfig } from "@proto-kit/common";
+
+import { BlockProverExecutionData } from "../prover/block/BlockProvable";
+
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+
+export abstract class ProvableTransactionHook<
+  Config = NoConfig,
+> extends TransitioningProtocolModule<Config> {
+  public abstract onTransaction(
+    executionData: BlockProverExecutionData
+  ): Promise<void>;
+}

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/block/BlockProvable.ts

@@ -0,0 +1,99 @@
+import {
+  Bool,
+  DynamicProof,
+  Field,
+  Proof,
+  Signature,
+  Struct,
+  Void,
+} from "o1js";
+import { WithZkProgrammable } from "@proto-kit/common";
+
+import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
+import { MethodPublicOutput } from "../../model/MethodPublicOutput";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../../model/network/NetworkState";
+
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
+import { RuntimeVerificationKeyAttestation } from "./accummulators/RuntimeVerificationKeyTree";
+
+export class BlockProverPublicInput extends Struct({
+  transactionsHash: Field,
+  stateRoot: Field,
+  networkStateHash: Field,
+  blockHashRoot: Field,
+  eternalTransactionsHash: Field,
+  incomingMessagesHash: Field,
+}) {}
+
+export class BlockProverPublicOutput extends Struct({
+  transactionsHash: Field,
+  stateRoot: Field,
+  networkStateHash: Field,
+  blockHashRoot: Field,
+  eternalTransactionsHash: Field,
+  incomingMessagesHash: Field,
+  closed: Bool,
+  blockNumber: Field,
+}) {
+  public equals(
+    input: BlockProverPublicInput,
+    closed: Bool,
+    blockNumber: Field
+  ): Bool {
+    const output2 = BlockProverPublicOutput.toFields({
+      ...input,
+      closed,
+      blockNumber,
+    });
+    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: RuntimeTransaction,
+  signature: Signature,
+  networkState: NetworkState,
+}) {}
+
+export class DynamicRuntimeProof extends DynamicProof<
+  Void,
+  MethodPublicOutput
+> {
+  static publicInputType = Void;
+
+  static publicOutputType = MethodPublicOutput;
+}
+
+export interface BlockProvable
+  extends WithZkProgrammable<BlockProverPublicInput, BlockProverPublicOutput> {
+  proveTransaction: (
+    publicInput: BlockProverPublicInput,
+    stateProof: StateTransitionProof,
+    appProof: DynamicRuntimeProof,
+    executionData: BlockProverExecutionData,
+    verificationKeyAttestation: RuntimeVerificationKeyAttestation
+  ) => Promise<BlockProverPublicOutput>;
+
+  proveBlock: (
+    publicInput: BlockProverPublicInput,
+    networkState: NetworkState,
+    blockWitness: BlockHashMerkleTreeWitness,
+    stateTransitionProof: StateTransitionProof,
+    transactionProof: BlockProverProof
+  ) => Promise<BlockProverPublicOutput>;
+
+  merge: (
+    publicInput: BlockProverPublicInput,
+    proof1: BlockProverProof,
+    proof2: BlockProverProof
+  ) => Promise<BlockProverPublicOutput>;
+}