Separate TransactionProver from BlockProver

packages/library/src/protocol/VanillaProtocolModules.ts

@@ -1,11 +1,7 @@
 import {
-  AccountStateHook,
-  BlockHeightHook,
-  BlockProver,
   MandatoryProtocolModulesRecord,
   ProtocolModulesRecord,
-  StateTransitionProver,
-  LastStateRootBlockHook,
+  Protocol,
 } from "@proto-kit/protocol";
 import { PrivateKey } from "o1js";
 
@@ -20,11 +16,7 @@ export class VanillaProtocolModules {
     additionalModules: ProtocolModules
   ): MandatoryProtocolModulesRecord & ProtocolModules {
     return {
-      StateTransitionProver,
-      BlockProver,
-      AccountState: AccountStateHook,
-      BlockHeight: BlockHeightHook,
-      LastStateRoot: LastStateRootBlockHook,
+      ...Protocol.defaultModules(),
       ...additionalModules,
     };
   }
@@ -40,11 +32,7 @@ export class VanillaProtocolModules {
 
   public static mandatoryConfig() {
     return {
-      BlockProver: {},
-      StateTransitionProver: {},
-      AccountState: {},
-      BlockHeight: {},
-      LastStateRoot: {},
+      ...Protocol.defaultConfig(),
     };
   }
 

packages/protocol/src/index.ts

@@ -29,6 +29,9 @@ export * from "./prover/block/accummulators/BlockHashMerkleTree";
 export * from "./prover/block/services/RuntimeVerificationKeyRootService";
 export * from "./prover/statetransition/StateTransitionProver";
 export * from "./prover/statetransition/StateTransitionProvable";
+export * from "./prover/transaction/TransactionProver";
+export * from "./prover/transaction/TransactionProvable";
+export * from "./prover/utils";
 export * from "./protocol/Protocol";
 export * from "./protocol/ProtocolModule";
 export * from "./protocol/ProtocolEnvironment";

packages/protocol/src/protocol/Protocol.ts

@@ -3,6 +3,7 @@ import {
   ChildContainerProvider,
   log,
   ModuleContainer,
+  ModulesConfig,
   ModulesRecord,
   Startable,
   StringKeyOf,
@@ -21,6 +22,10 @@ import { ProvableSettlementHook } from "../settlement/modularity/ProvableSettlem
 import { NoopSettlementHook } from "../hooks/NoopSettlementHook";
 import { AccountStateHook } from "../hooks/AccountStateHook";
 import { NoopTransactionHook } from "../hooks/NoopTransactionHook";
+import { TransactionProvable } from "../prover/transaction/TransactionProvable";
+import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
+import { TransactionProver } from "../prover/transaction/TransactionProver";
+import { BlockProver } from "../prover/block/BlockProver";
 
 import { ProtocolModule } from "./ProtocolModule";
 import { ProvableTransactionHook } from "./ProvableTransactionHook";
@@ -44,13 +49,18 @@ export type ProtocolModulesRecord = ModulesRecord<
   TypedClass<ProtocolModule<unknown>>
 >;
 
+export interface TransactionProverType
+  extends ProtocolModule,
+    TransactionProvable {}
+
 export interface BlockProverType extends ProtocolModule, BlockProvable {}
 
 export interface StateTransitionProverType
   extends ProtocolModule,
     StateTransitionProvable {}
 
 export type MandatoryProtocolModulesRecord = {
+  TransactionProver: TypedClass<TransactionProverType>;
   BlockProver: TypedClass<BlockProverType>;
   StateTransitionProver: TypedClass<StateTransitionProverType>;
   AccountState: TypedClass<AccountStateHook>;
@@ -115,6 +125,14 @@ export class Protocol<
     return this.definition[moduleName] !== undefined;
   }
 
+  public get transactionProver(): TransactionProvable {
+    // Why do I resolve directly here?
+    // I don't know exactly but generics don't let me use .resolve()
+    return this.container.resolve<InstanceType<Modules["TransactionProver"]>>(
+      "TransactionProver"
+    );
+  }
+
   public get blockProver(): BlockProvable {
     // Why do I resolve directly here?
     // I don't know exactly but generics don't let me use .resolve()
@@ -129,6 +147,28 @@ export class Protocol<
     >("StateTransitionProver");
   }
 
+  public static defaultModules() {
+    return {
+      StateTransitionProver,
+      TransactionProver,
+      BlockProver,
+      AccountState: AccountStateHook,
+      BlockHeight: BlockHeightHook,
+      LastStateRoot: LastStateRootBlockHook,
+    };
+  }
+
+  public static defaultConfig() {
+    return {
+      StateTransitionProver: {},
+      TransactionProver: {},
+      BlockProver: {},
+      AccountState: {},
+      BlockHeight: {},
+      LastStateRoot: {},
+    } satisfies ModulesConfig<ReturnType<typeof Protocol.defaultModules>>;
+  }
+
   public getAreProofsEnabled(): AreProofsEnabled {
     return this.container.resolve<AreProofsEnabled>("AreProofsEnabled");
   }

packages/protocol/src/protocol/ProvableBlockHook.ts

@@ -2,54 +2,48 @@ import { Field } from "o1js";
 import { NoConfig } from "@proto-kit/common";
 
 import { NetworkState } from "../model/network/NetworkState";
-import { MethodPublicOutput } from "../model/MethodPublicOutput";
-import { BlockProverTransactionArguments } from "../prover/block/BlockProvable";
-
-import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 import {
-  AfterTransactionHookArguments,
-  BeforeTransactionHookArguments,
-  ProvableHookBlockState,
-  toProvableHookBlockState,
-} from "./ProvableTransactionHook";
-
-export interface BeforeBlockHookArguments extends ProvableHookBlockState {}
-
-export interface AfterBlockHookArguments extends BeforeBlockHookArguments {
-  stateRoot: Field;
-}
+  BlockProverState,
+  BlockProverPublicInput,
+} from "../prover/block/BlockProvable";
 
-export function toBeforeTransactionHookArgument(
-  executionData: Omit<
-    BlockProverTransactionArguments,
-    "verificationKeyAttestation"
-  >,
-  networkState: NetworkState,
-  state: Parameters<typeof toProvableHookBlockState>[0]
-): BeforeTransactionHookArguments {
-  const { transaction, signature } = executionData;
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 
+export type ProvableHookBlockState = Pick<
+  BlockProverPublicInput,
+  | "transactionsHash"
+  | "eternalTransactionsHash"
+  | "incomingMessagesHash"
+  | "blockHashRoot"
+>;
+
+export function toProvableHookBlockState(
+  state: Pick<
+    BlockProverState,
+    | "transactionList"
+    | "eternalTransactionsList"
+    | "incomingMessages"
+    | "blockHashRoot"
+  >
+) {
+  const {
+    transactionList,
+    eternalTransactionsList,
+    incomingMessages,
+    blockHashRoot,
+  } = state;
   return {
-    networkState,
-    transaction,
-    signature,
-    prover: toProvableHookBlockState(state),
+    transactionsHash: transactionList.commitment,
+    eternalTransactionsHash: eternalTransactionsList.commitment,
+    incomingMessagesHash: incomingMessages.commitment,
+    blockHashRoot,
   };
 }
 
-export function toAfterTransactionHookArgument(
-  executionData: Omit<
-    BlockProverTransactionArguments,
-    "verificationKeyAttestation"
-  >,
-  networkState: NetworkState,
-  state: Parameters<typeof toProvableHookBlockState>[0],
-  runtimeResult: MethodPublicOutput
-): AfterTransactionHookArguments {
-  return {
-    ...toBeforeTransactionHookArgument(executionData, networkState, state),
-    runtimeResult,
-  };
+export interface BeforeBlockHookArguments extends ProvableHookBlockState {}
+
+export interface AfterBlockHookArguments extends BeforeBlockHookArguments {
+  stateRoot: Field;
 }
 
 // Purpose is to build transition from -> to network state

packages/protocol/src/protocol/ProvableTransactionHook.ts

@@ -4,41 +4,63 @@ import { Signature } from "o1js";
 import { RuntimeTransaction } from "../model/transaction/RuntimeTransaction";
 import { NetworkState } from "../model/network/NetworkState";
 import { MethodPublicOutput } from "../model/MethodPublicOutput";
-import type {
-  BlockProverState,
-  BlockProverStateCommitments,
-} from "../prover/block/BlockProvable";
+import {
+  TransactionProverPublicInput,
+  TransactionProverState,
+  TransactionProverTransactionArguments,
+} from "../prover/transaction/TransactionProvable";
 
 import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 
-export type ProvableHookBlockState = Pick<
-  BlockProverStateCommitments,
-  | "transactionsHash"
-  | "eternalTransactionsHash"
-  | "incomingMessagesHash"
-  | "blockHashRoot"
+export type ProvableHookTransactionState = Pick<
+  TransactionProverPublicInput,
+  "transactionsHash" | "eternalTransactionsHash" | "incomingMessagesHash"
 >;
 
-export function toProvableHookBlockState(
+export function toProvableHookTransactionState(
   state: Pick<
-    BlockProverState,
-    | "transactionList"
-    | "eternalTransactionsList"
-    | "incomingMessages"
-    | "blockHashRoot"
+    TransactionProverState,
+    "transactionList" | "eternalTransactionsList" | "incomingMessages"
   >
 ) {
-  const {
-    transactionList,
-    eternalTransactionsList,
-    incomingMessages,
-    blockHashRoot,
-  } = state;
+  const { transactionList, eternalTransactionsList, incomingMessages } = state;
   return {
     transactionsHash: transactionList.commitment,
     eternalTransactionsHash: eternalTransactionsList.commitment,
     incomingMessagesHash: incomingMessages.commitment,
-    blockHashRoot,
+  };
+}
+
+export function toBeforeTransactionHookArgument(
+  executionData: Omit<
+    TransactionProverTransactionArguments,
+    "verificationKeyAttestation"
+  >,
+  networkState: NetworkState,
+  state: Parameters<typeof toProvableHookTransactionState>[0]
+): BeforeTransactionHookArguments {
+  const { transaction, signature } = executionData;
+
+  return {
+    networkState,
+    transaction,
+    signature,
+    prover: toProvableHookTransactionState(state),
+  };
+}
+
+export function toAfterTransactionHookArgument(
+  executionData: Omit<
+    TransactionProverTransactionArguments,
+    "verificationKeyAttestation"
+  >,
+  networkState: NetworkState,
+  state: Parameters<typeof toProvableHookTransactionState>[0],
+  runtimeResult: MethodPublicOutput
+): AfterTransactionHookArguments {
+  return {
+    ...toBeforeTransactionHookArgument(executionData, networkState, state),
+    runtimeResult,
   };
 }
 
@@ -56,7 +78,7 @@ export interface BeforeTransactionHookArguments {
   transaction: RuntimeTransaction;
   signature: Signature;
   networkState: NetworkState;
-  prover: ProvableHookBlockState;
+  prover: ProvableHookTransactionState;
 }
 
 export interface AfterTransactionHookArguments