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

package/src/model/Option.ts

@@ -19,7 +19,10 @@ export class ProvableOption extends Struct({
 }
 
 export abstract class OptionBase {
-  protected constructor(public isSome: Bool, public isForcedSome: Bool) {}
+  protected constructor(
+    public isSome: Bool,
+    public isForcedSome: Bool
+  ) {}
 
   protected abstract encodeValueToFields(): Field[];
 
@@ -152,6 +155,7 @@ export class Option<Value> extends OptionBase {
   }
 
   public toConstant() {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const valueConstant = (this.valueType as ProvablePure<Value>).fromFields(
       this.valueType.toFields(this.value).map((field) => field.toConstant())
     );

package/src/model/Path.ts

@@ -1,6 +1,4 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @shopify/no-fully-static-classes */
-import { Field, type FlexibleProvablePure, Poseidon, Provable } from "o1js";
+import { Field, type FlexibleProvablePure, Poseidon } from "o1js";
 
 import { stringToField } from "../utils/utils";
 

package/src/model/StateTransition.ts

@@ -1,4 +1,4 @@
-import { Bool, Field, ProvablePure, Struct } from "o1js";
+import { Field, Struct } from "o1js";
 
 import { Option, ProvableOption } from "./Option";
 

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 { ProtocolModule } from "./ProtocolModule";
-import { ProvableTransactionHook } from "./ProvableTransactionHook";
-import { NoopTransactionHook } from "../hooks/NoopTransactionHook";
-import { ProtocolEnvironment } from "./ProtocolEnvironment";
-import { AccountStateHook } from "../hooks/AccountStateHook";
-import { ProvableBlockHook } from "./ProvableBlockHook";
+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 { ProtocolEnvironment } from "./ProtocolEnvironment";
+import { ProvableBlockHook } from "./ProvableBlockHook";
 
 const PROTOCOL_INJECTION_TOKENS: Record<string, string> = {
   ProvableTransactionHook: "ProvableTransactionHook",
@@ -59,13 +57,13 @@ export interface ProtocolDefinition<Modules extends ProtocolModulesRecord> {
 }
 
 export class Protocol<
-    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord
+    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord,
   >
   extends ModuleContainer<Modules>
   implements ProtocolEnvironment
 {
   public static from<
-    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord
+    Modules extends ProtocolModulesRecord & MandatoryProtocolModulesRecord,
   >(modules: ProtocolDefinition<Modules>): TypedClass<Protocol<Modules>> {
     return class ScopedProtocol extends Protocol<Modules> {
       public constructor() {
@@ -81,7 +79,7 @@ export class Protocol<
     this.definition = definition;
   }
 
-  public get stateService(): StateService {
+  public get stateService(): SimpleAsyncStateService {
     return this.stateServiceProvider.stateService;
   }
 
@@ -183,4 +181,17 @@ export class Protocol<
       }
     });
   }
+
+  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

@@ -9,7 +9,7 @@ import {
 import { ProtocolEnvironment } from "./ProtocolEnvironment";
 
 export abstract class ProtocolModule<
-  Config = NoConfig
+  Config = NoConfig,
 > extends ConfigurableModule<Config> {
   public protocol?: ProtocolEnvironment;
 
@@ -17,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>;
 }

package/src/prover/block/BlockProver.ts

@@ -1,17 +1,15 @@
-/* eslint-disable max-lines */
 import {
   Bool,
-  Experimental,
   Field,
   Poseidon,
   type Proof,
   Provable,
   SelfProof,
+  ZkProgram,
 } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
 import {
   AreProofsEnabled,
-  hashWithPrefix,
   PlainZkProgram,
   provableMethod,
   WithZkProgrammable,
@@ -123,7 +121,6 @@ export class BlockProverProgrammable extends ZkProgrammable<
   BlockProverPublicOutput
 > {
   public constructor(
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
     private readonly prover: BlockProver,
     public readonly stateTransitionProver: ZkProgrammable<
       StateTransitionProverPublicInput,
@@ -150,7 +147,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
    * @param executionData
    * @returns The new BlockProver-state to be used as public output
    */
-  public applyTransaction(
+  public async applyTransaction(
     state: BlockProverState,
     stateTransitionProof: Proof<
       StateTransitionProverPublicInput,
@@ -158,10 +155,10 @@ export class BlockProverProgrammable extends ZkProgrammable<
     >,
     runtimeProof: RuntimeProof,
     executionData: BlockProverExecutionData
-  ): BlockProverState {
+  ): Promise<BlockProverState> {
     const { transaction, networkState, signature } = executionData;
 
-    const isMessage = runtimeProof.publicOutput.isMessage;
+    const { isMessage } = runtimeProof.publicOutput;
 
     runtimeProof.verify();
     stateTransitionProof.verify();
@@ -194,7 +191,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
     );
 
     // Apply protocol state transitions
-    this.assertProtocolTransitions(
+    await this.assertProtocolTransitions(
       stateTransitionProof,
       executionData,
       runtimeProof
@@ -240,10 +237,10 @@ export class BlockProverProgrammable extends ZkProgrammable<
     return stateTo;
   }
 
-  // eslint-disable-next-line no-warning-comments, max-len
+  // eslint-disable-next-line max-len
   // TODO How does this interact with the RuntimeMethodExecutionContext when executing runtimemethods?
 
-  public assertProtocolTransitions(
+  public async assertProtocolTransitions(
     stateTransitionProof: Proof<
       StateTransitionProverPublicInput,
       StateTransitionProverPublicOutput
@@ -264,9 +261,10 @@ export class BlockProverProgrammable extends ZkProgrammable<
     });
     executionContext.beforeMethod("", "", []);
 
-    this.transactionHooks.forEach((module) => {
-      module.onTransaction(executionData);
-    });
+    for (const module of this.transactionHooks) {
+      // eslint-disable-next-line no-await-in-loop
+      await module.onTransaction(executionData);
+    }
 
     executionContext.afterMethod();
 
@@ -294,38 +292,38 @@ export class BlockProverProgrammable extends ZkProgrammable<
     );
   }
 
-  private executeBlockHooks(
+  private async executeBlockHooks(
     state: BlockProverState,
     inputNetworkState: NetworkState,
     type: "afterBlock" | "beforeBlock"
-  ): {
+  ): Promise<{
     networkState: NetworkState;
     stateTransitions: StateTransition<unknown>[];
-  } {
+  }> {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     executionContext.clear();
     executionContext.beforeMethod("", "", []);
 
-    const resultingNetworkState = this.blockHooks.reduce<NetworkState>(
-      (networkState, blockHook) => {
-        // Setup context for potential calls to runtime methods.
-        // With the special case that we set the new networkstate for every hook
-        // We also have to put in a dummy transaction for network.transaction
-        executionContext.setup({
-          transaction: RuntimeTransaction.dummyTransaction(),
-          networkState,
-        });
-
-        if (type === "beforeBlock") {
-          return blockHook.beforeBlock(networkState, state);
-        } else if (type === "afterBlock") {
-          return blockHook.afterBlock(networkState, state);
-        } else {
-          throw new Error("Unreachable");
-        }
-      },
-      inputNetworkState
-    );
+    const resultingNetworkState = await this.blockHooks.reduce<
+      Promise<NetworkState>
+    >(async (networkStatePromise, blockHook) => {
+      const networkState = await networkStatePromise;
+      // Setup context for potential calls to runtime methods.
+      // With the special case that we set the new networkstate for every hook
+      // We also have to put in a dummy transaction for network.transaction
+      executionContext.setup({
+        transaction: RuntimeTransaction.dummyTransaction(),
+        networkState,
+      });
+
+      if (type === "beforeBlock") {
+        return await blockHook.beforeBlock(networkState, state);
+      }
+      if (type === "afterBlock") {
+        return await blockHook.afterBlock(networkState, state);
+      }
+      throw new Error("Unreachable");
+    }, Promise.resolve(inputNetworkState));
 
     executionContext.afterMethod();
 
@@ -361,7 +359,6 @@ export class BlockProverProgrammable extends ZkProgrammable<
     stateTo.transactionsHash = transactionList.commitment;
 
     // Append tx to eternal transaction list
-    // eslint-disable-next-line no-warning-comments
     // TODO Change that to the a sequence-state compatible transaction struct
     const eternalTransactionList = new DefaultProvableHashList(
       Field,
@@ -385,12 +382,12 @@ export class BlockProverProgrammable extends ZkProgrammable<
   }
 
   @provableMethod()
-  public proveTransaction(
+  public async proveTransaction(
     publicInput: BlockProverPublicInput,
     stateProof: StateTransitionProof,
     runtimeProof: RuntimeProof,
     executionData: BlockProverExecutionData
-  ): BlockProverPublicOutput {
+  ): Promise<BlockProverPublicOutput> {
     const state: BlockProverState = {
       ...publicInput,
     };
@@ -406,7 +403,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       executionData.transaction
     );
 
-    const stateTo = this.applyTransaction(
+    const stateTo = await this.applyTransaction(
       bundleInclusionState,
       stateProof,
       runtimeProof,
@@ -441,13 +438,13 @@ export class BlockProverProgrammable extends ZkProgrammable<
   }
 
   @provableMethod()
-  public proveBlock(
+  public async proveBlock(
     publicInput: BlockProverPublicInput,
     networkState: NetworkState,
     blockWitness: BlockHashMerkleTreeWitness,
     stateTransitionProof: StateTransitionProof,
     transactionProof: BlockProverProof
-  ): BlockProverPublicOutput {
+  ): Promise<BlockProverPublicOutput> {
     const state: BlockProverState = {
       ...publicInput,
     };
@@ -507,7 +504,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
     transactionProof.verifyIf(verifyTransactionProof);
 
     // 2. Execute beforeBlock hooks
-    const beforeBlockResult = this.executeBlockHooks(
+    const beforeBlockResult = await this.executeBlockHooks(
       state,
       networkState,
       "beforeBlock"
@@ -555,7 +552,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
     // 5. Execute afterBlock hooks
     this.assertSTProofInput(stateTransitionProof, state.stateRoot);
 
-    const afterBlockResult = this.executeBlockHooks(
+    const afterBlockResult = await this.executeBlockHooks(
       state,
       beforeBlockResult.networkState,
       "afterBlock"
@@ -609,11 +606,11 @@ export class BlockProverProgrammable extends ZkProgrammable<
   }
 
   @provableMethod()
-  public merge(
+  public async merge(
     publicInput: BlockProverPublicInput,
     proof1: BlockProverProof,
     proof2: BlockProverProof
-  ): BlockProverPublicOutput {
+  ): Promise<BlockProverPublicOutput> {
     proof1.verify();
     proof2.verify();
 
@@ -755,9 +752,11 @@ export class BlockProverProgrammable extends ZkProgrammable<
     const RuntimeProofClass = runtime.zkProgram.Proof;
 
     const proveTransaction = prover.proveTransaction.bind(prover);
+    const proveBlock = prover.proveBlock.bind(prover);
     const merge = prover.merge.bind(prover);
 
-    const program = Experimental.ZkProgram({
+    const program = ZkProgram({
+      name: "BlockProver",
       publicInput: BlockProverPublicInput,
       publicOutput: BlockProverPublicOutput,
 
@@ -769,13 +768,13 @@ export class BlockProverProgrammable extends ZkProgrammable<
             BlockProverExecutionData,
           ],
 
-          method(
+          async method(
             publicInput: BlockProverPublicInput,
             stateProof: StateTransitionProof,
             appProof: Proof<void, MethodPublicOutput>,
             executionData: BlockProverExecutionData
           ) {
-            return proveTransaction(
+            return await proveTransaction(
               publicInput,
               stateProof,
               appProof,
@@ -784,18 +783,42 @@ export class BlockProverProgrammable extends ZkProgrammable<
           },
         },
 
+        proveBlock: {
+          privateInputs: [
+            NetworkState,
+            BlockHashMerkleTreeWitness,
+            StateTransitionProofClass,
+            SelfProof<BlockProverPublicInput, BlockProverPublicOutput>,
+          ],
+          async method(
+            publicInput: BlockProverPublicInput,
+            networkState: NetworkState,
+            blockWitness: BlockHashMerkleTreeWitness,
+            stateTransitionProof: StateTransitionProof,
+            transactionProof: BlockProverProof
+          ) {
+            return await proveBlock(
+              publicInput,
+              networkState,
+              blockWitness,
+              stateTransitionProof,
+              transactionProof
+            );
+          },
+        },
+
         merge: {
           privateInputs: [
             SelfProof<BlockProverPublicInput, BlockProverPublicOutput>,
             SelfProof<BlockProverPublicInput, BlockProverPublicOutput>,
           ],
 
-          method(
+          async method(
             publicInput: BlockProverPublicInput,
             proof1: BlockProverProof,
             proof2: BlockProverProof
           ) {
-            return merge(publicInput, proof1, proof2);
+            return await merge(publicInput, proof1, proof2);
           },
         },
       },
@@ -806,7 +829,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       merge: program.merge,
     };
 
-    const SelfProofClass = Experimental.ZkProgram.Proof(program);
+    const SelfProofClass = ZkProgram.Proof(program);
 
     return {
       compile: program.compile.bind(program),
@@ -855,7 +878,7 @@ export class BlockProver extends ProtocolModule implements BlockProvable {
     stateProof: StateTransitionProof,
     appProof: Proof<void, MethodPublicOutput>,
     executionData: BlockProverExecutionData
-  ): BlockProverPublicOutput {
+  ): Promise<BlockProverPublicOutput> {
     return this.zkProgrammable.proveTransaction(
       publicInput,
       stateProof,
@@ -870,7 +893,7 @@ export class BlockProver extends ProtocolModule implements BlockProvable {
     blockWitness: BlockHashMerkleTreeWitness,
     stateTransitionProof: StateTransitionProof,
     transactionProof: BlockProverProof
-  ): BlockProverPublicOutput {
+  ): Promise<BlockProverPublicOutput> {
     return this.zkProgrammable.proveBlock(
       publicInput,
       networkState,
@@ -884,7 +907,7 @@ export class BlockProver extends ProtocolModule implements BlockProvable {
     publicInput: BlockProverPublicInput,
     proof1: BlockProverProof,
     proof2: BlockProverProof
-  ): BlockProverPublicOutput {
+  ): Promise<BlockProverPublicOutput> {
     return this.zkProgrammable.merge(publicInput, proof1, proof2);
   }
 }

package/src/prover/block/accummulators/BlockHashMerkleTree.ts

@@ -1,5 +1,5 @@
 import { createMerkleTree } from "@proto-kit/common";
-import { Bool, Field, Poseidon, Provable, Struct } from "o1js";
+import { Bool, Field, Poseidon, Struct } from "o1js";
 
 export class BlockHashMerkleTree extends createMerkleTree(40) {}
 export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {}

package/src/prover/statetransition/StateTransitionProvable.ts

@@ -1,5 +1,5 @@
 import { Field, Proof, Struct } from "o1js";
-import { WithZkProgrammable, ZkProgrammable } from "@proto-kit/common";
+import { WithZkProgrammable } from "@proto-kit/common";
 
 import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
 
@@ -34,11 +34,11 @@ export interface StateTransitionProvable
   runBatch: (
     publicInput: StateTransitionProverPublicInput,
     batch: StateTransitionProvableBatch
-  ) => StateTransitionProverPublicOutput;
+  ) => Promise<StateTransitionProverPublicOutput>;
 
   merge: (
     publicInput: StateTransitionProverPublicInput,
     proof1: StateTransitionProof,
     proof2: StateTransitionProof
-  ) => StateTransitionProverPublicOutput;
+  ) => Promise<StateTransitionProverPublicOutput>;
 }