@proto-kit/protocol 0.1.1-develop.600 → 0.1.1-develop.833

package/src/model/StateTransition.ts

@@ -44,7 +44,7 @@ export class StateTransition<Value> {
 
   public constructor(
     public path: Field,
-    public fromValue: Option<Field> | Option<Value>,
+    public fromValue: Option<Value>,
     public toValue: Option<Field> | Option<Value>
   ) {}
 
@@ -77,4 +77,12 @@ export class StateTransition<Value> {
       to: this.toValue.toJSON(),
     };
   }
+
+  public toConstant(): StateTransition<Value> {
+    return new StateTransition<Value>(
+      this.path.toConstant(),
+      this.fromValue.toConstant(),
+      this.toValue.toConstant()
+    );
+  }
 }

package/src/model/Transaction.ts

@@ -8,11 +8,13 @@ import {
   UInt64,
 } from "o1js";
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function argsToHash(...args: FlexibleProvable<any>[]): Field {
   const fields = args.flatMap((argument) => argument.toFields(argument));
   return Poseidon.hash(fields);
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 class Transaction extends Struct({
   // must be checked inside @runtimeMethod
   methodId: Field,

package/src/model/network/NetworkState.ts

@@ -26,8 +26,8 @@ export class NetworkState extends Struct({
         height: UInt64.zero,
       },
       previous: {
-        rootHash: Field(RollupMerkleTree.EMPTY_ROOT)
-      }
+        rootHash: Field(RollupMerkleTree.EMPTY_ROOT),
+      },
     });
   }
 }

package/src/model/transaction/RuntimeTransaction.ts

@@ -1,15 +1,8 @@
-import {
-  Bool,
-  Field,
-  Poseidon,
-  Provable,
-  PublicKey,
-  Struct,
-  UInt64,
-} from "o1js";
-import { PublicKeyOption, UInt64Option } from "./ValueOption";
+import { Bool, Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
 import { EMPTY_PUBLICKEY, EMPTY_PUBLICKEY_X } from "@proto-kit/common";
 
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
+
 /**
  * This struct is used to expose transaction information to the runtime method
  * execution. This class has not all data included in transactions on purpose.
@@ -30,8 +23,8 @@ export class RuntimeTransaction extends Struct({
     return new RuntimeTransaction({
       methodId: input.methodId,
       argsHash: input.argsHash,
-      nonce: UInt64Option.fromValue(input.nonce),
-      sender: PublicKeyOption.fromValue(input.sender),
+      nonce: UInt64Option.fromSome(input.nonce),
+      sender: PublicKeyOption.fromSome(input.sender),
     });
   }
 

package/src/model/transaction/SignedTransaction.ts

@@ -1,11 +1,4 @@
-import {
-  Bool,
-  Field,
-  Scalar,
-  Signature,
-  Struct,
-  UInt64,
-} from "o1js";
+import { Bool, Field, Scalar, Signature, Struct, UInt64 } from "o1js";
 
 import { RuntimeTransaction } from "./RuntimeTransaction";
 

package/src/model/transaction/ValueOption.ts

@@ -5,7 +5,7 @@ function genericOptionFactory<Type>(valueType: ProvableExtended<Type>) {
     isSome: Bool,
     value: valueType,
   }) {
-    public static fromValue(value: Type) {
+    public static fromSome(value: Type) {
       return new Generic({
         isSome: Bool(true),
         value,

package/src/protocol/Protocol.ts

@@ -11,23 +11,21 @@ import {
 import { DependencyContainer, Lifecycle } from "tsyringe";
 
 import { BlockProvable } from "../prover/block/BlockProvable";
-import { StateTransitionProver } from "../prover/statetransition/StateTransitionProver";
 import { StateTransitionProvable } from "../prover/statetransition/StateTransitionProvable";
-import { BlockProver } from "../prover/block/BlockProver";
 import { StateServiceProvider } from "../state/StateServiceProvider";
-import { StateService } from "../state/StateService";
+import { SimpleAsyncStateService } from "../state/StateService";
+import { NoopBlockHook } from "../hooks/NoopBlockHook";
+import { BlockHeightHook } from "../hooks/BlockHeightHook";
+import { LastStateRootBlockHook } from "../hooks/LastStateRootBlockHook";
+import { ProvableSettlementHook } from "../settlement/modularity/ProvableSettlementHook";
+import { NoopSettlementHook } from "../hooks/NoopSettlementHook";
+import { AccountStateHook } from "../hooks/AccountStateHook";
+import { NoopTransactionHook } from "../hooks/NoopTransactionHook";
 
 import { ProtocolModule } from "./ProtocolModule";
 import { ProvableTransactionHook } from "./ProvableTransactionHook";
-import { NoopTransactionHook } from "../blockmodules/NoopTransactionHook";
 import { ProtocolEnvironment } from "./ProtocolEnvironment";
-import { AccountStateModule } from "../blockmodules/AccountStateModule";
 import { ProvableBlockHook } from "./ProvableBlockHook";
-import { NoopBlockHook } from "../blockmodules/NoopBlockHook";
-import { BlockHeightHook } from "../blockmodules/BlockHeightHook";
-import { LastStateRootBlockHook } from "../blockmodules/LastStateRootBlockHook";
-import { ProvableSettlementHook } from "../settlement/ProvableSettlementHook";
-import { NoopSettlementHook } from "../blockmodules/NoopSettlementHook";
 
 const PROTOCOL_INJECTION_TOKENS: Record<string, string> = {
   ProvableTransactionHook: "ProvableTransactionHook",
@@ -35,42 +33,38 @@ const PROTOCOL_INJECTION_TOKENS: Record<string, string> = {
   ProvableSettlementHook: "ProvableSettlementHook",
 };
 
-export type GenericProtocolModuleRecord = ModulesRecord<
+export type ProtocolModulesRecord = ModulesRecord<
   TypedClass<ProtocolModule<unknown>>
 >;
 
-interface BlockProverType extends ProtocolModule, BlockProvable {}
+export interface BlockProverType extends ProtocolModule, BlockProvable {}
 
-interface StateTransitionProverType
+export interface StateTransitionProverType
   extends ProtocolModule,
     StateTransitionProvable {}
 
-export interface ProtocolCustomModulesRecord
-  extends GenericProtocolModuleRecord {
+export type MandatoryProtocolModulesRecord = {
   BlockProver: TypedClass<BlockProverType>;
   StateTransitionProver: TypedClass<StateTransitionProverType>;
-  AccountState: TypedClass<AccountStateModule>;
+  AccountState: TypedClass<AccountStateHook>;
   BlockHeight: TypedClass<BlockHeightHook>;
   LastStateRoot: TypedClass<LastStateRootBlockHook>;
-}
-
-export interface ProtocolModulesRecord
-  extends GenericProtocolModuleRecord,
-    ProtocolCustomModulesRecord {}
+};
 
 export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
   modules: Modules;
   config?: ModulesConfig<Modules>;
 }
 
-export class Protocol<Modules extends ProtocolModulesRecord>
+export class Protocol<
+    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord,
+  >
   extends ModuleContainer<Modules>
   implements ProtocolEnvironment
 {
-  // .from() to create Protocol
-  public static from<Modules extends ProtocolModulesRecord>(
-    modules: ProtocolDefinition<Modules>
-  ): TypedClass<Protocol<Modules>> {
+  public static from<
+    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord,
+  >(modules: ProtocolDefinition<Modules>): TypedClass<Protocol<Modules>> {
     return class ScopedProtocol extends Protocol<Modules> {
       public constructor() {
         super(modules);
@@ -85,7 +79,7 @@ export class Protocol<Modules extends ProtocolModulesRecord>
     this.definition = definition;
   }
 
-  public get stateService(): StateService {
+  public get stateService(): SimpleAsyncStateService {
     return this.stateServiceProvider.stateService;
   }
 
@@ -187,25 +181,17 @@ export class Protocol<Modules extends ProtocolModulesRecord>
       }
     });
   }
-}
 
-export const VanillaProtocol = {
-  create() {
-    return VanillaProtocol.from({});
-  },
-
-  from<AdditonalModules extends GenericProtocolModuleRecord>(
-    additionalModules: AdditonalModules
-  ): TypedClass<Protocol<ProtocolCustomModulesRecord & AdditonalModules>> {
-    return Protocol.from<ProtocolCustomModulesRecord & AdditonalModules>({
-      modules: {
-        StateTransitionProver,
-        BlockProver,
-        AccountState: AccountStateModule,
-        BlockHeight: BlockHeightHook,
-        LastStateRoot: LastStateRootBlockHook,
-        ...additionalModules,
-      },
-    });
-  },
-};
+  public async start() {
+    // eslint-disable-next-line guard-for-in
+    for (const moduleName in this.definition.modules) {
+      const protocolModule = this.resolve(moduleName);
+
+      log.info(
+        `Starting protocol module ${moduleName} (${protocolModule.constructor.name})`
+      );
+      // eslint-disable-next-line no-await-in-loop
+      await protocolModule.start();
+    }
+  }
+}

package/src/protocol/ProtocolEnvironment.ts

@@ -1,9 +1,10 @@
-import { StateService } from "../state/StateService";
-import { StateServiceProvider } from "../state/StateServiceProvider";
 import { AreProofsEnabled } from "@proto-kit/common";
 
+import { SimpleAsyncStateService } from "../state/StateService";
+import { StateServiceProvider } from "../state/StateServiceProvider";
+
 export interface ProtocolEnvironment {
-  get stateService(): StateService
-  get stateServiceProvider(): StateServiceProvider
-  getAreProofsEnabled(): AreProofsEnabled
-}
+  get stateService(): SimpleAsyncStateService;
+  get stateServiceProvider(): StateServiceProvider;
+  getAreProofsEnabled(): AreProofsEnabled;
+}

package/src/protocol/ProtocolModule.ts

@@ -1,14 +1,15 @@
 import {
   AreProofsEnabled,
   ChildContainerProvider,
-  ConfigurableModule, NoConfig,
-  noop
+  ConfigurableModule,
+  NoConfig,
+  noop,
 } from "@proto-kit/common";
 
 import { ProtocolEnvironment } from "./ProtocolEnvironment";
 
 export abstract class ProtocolModule<
-  Config = NoConfig
+  Config = NoConfig,
 > extends ConfigurableModule<Config> {
   public protocol?: ProtocolEnvironment;
 
@@ -16,8 +17,11 @@ export abstract class ProtocolModule<
     return this.protocol?.getAreProofsEnabled();
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public create(childContainerProvider: ChildContainerProvider): void {
     noop();
   }
+
+  public async start() {
+    noop();
+  }
 }

package/src/protocol/ProvableBlockHook.ts

@@ -5,15 +5,15 @@ import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 
 // Purpose is to build transition from -> to network state
 export abstract class ProvableBlockHook<
-  Config
+  Config,
 > extends TransitioningProtocolModule<Config> {
   public abstract beforeBlock(
     networkState: NetworkState,
     state: BlockProverState
-  ): NetworkState;
+  ): Promise<NetworkState>;
 
   public abstract afterBlock(
     networkState: NetworkState,
     state: BlockProverState
-  ): NetworkState;
+  ): Promise<NetworkState>;
 }

package/src/protocol/ProvableTransactionHook.ts

@@ -5,7 +5,9 @@ import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 
 export abstract class ProvableTransactionHook<
-  Config = NoConfig
+  Config = NoConfig,
 > extends TransitioningProtocolModule<Config> {
-  public abstract onTransaction(executionData: BlockProverExecutionData): void;
+  public abstract onTransaction(
+    executionData: BlockProverExecutionData
+  ): Promise<void>;
 }

package/src/protocol/TransitioningProtocolModule.ts

@@ -6,7 +6,7 @@ import { ProtocolModule } from "./ProtocolModule";
  * of a `name: string` property, which those classes need to function.
  */
 export abstract class TransitioningProtocolModule<
-  Config
+  Config,
 > extends ProtocolModule<Config> {
   public name?: string;
 }

package/src/prover/block/BlockProvable.ts

@@ -62,7 +62,7 @@ export interface BlockProvable
     stateProof: StateTransitionProof,
     appProof: Proof<void, MethodPublicOutput>,
     executionData: BlockProverExecutionData
-  ) => BlockProverPublicOutput;
+  ) => Promise<BlockProverPublicOutput>;
 
   proveBlock: (
     publicInput: BlockProverPublicInput,
@@ -70,11 +70,11 @@ export interface BlockProvable
     blockWitness: BlockHashMerkleTreeWitness,
     stateTransitionProof: StateTransitionProof,
     transactionProof: BlockProverProof
-  ) => BlockProverPublicOutput;
+  ) => Promise<BlockProverPublicOutput>;
 
   merge: (
     publicInput: BlockProverPublicInput,
     proof1: BlockProverProof,
     proof2: BlockProverProof
-  ) => BlockProverPublicOutput;
+  ) => Promise<BlockProverPublicOutput>;
 }