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

package/src/prover/block/BlockProver.ts

@@ -1,16 +1,15 @@
-/* eslint-disable max-lines */
 import {
   Bool,
-  Experimental,
-  Field, Poseidon,
+  Field,
+  Poseidon,
   type Proof,
   Provable,
-  SelfProof
+  SelfProof,
+  ZkProgram,
 } from "o1js";
 import { container, inject, injectable, injectAll } from "tsyringe";
 import {
   AreProofsEnabled,
-  hashWithPrefix,
   PlainZkProgram,
   provableMethod,
   WithZkProgrammable,
@@ -35,7 +34,11 @@ import { RuntimeMethodExecutionContext } from "../../state/context/RuntimeMethod
 import { ProvableBlockHook } from "../../protocol/ProvableBlockHook";
 import { NetworkState } from "../../model/network/NetworkState";
 import { SignedTransaction } from "../../model/transaction/SignedTransaction";
-import { MinaActions, MinaActionsHashList } from "../../utils/MinaPrefixedProvableHashList";
+import {
+  MinaActions,
+  MinaActionsHashList,
+} from "../../utils/MinaPrefixedProvableHashList";
+import { StateTransitionReductionList } from "../../utils/StateTransitionReductionList";
 
 import {
   BlockProvable,
@@ -118,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,
@@ -145,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,
@@ -153,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();
@@ -189,7 +191,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
     );
 
     // Apply protocol state transitions
-    this.assertProtocolTransitions(
+    await this.assertProtocolTransitions(
       stateTransitionProof,
       executionData,
       runtimeProof
@@ -235,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
@@ -259,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();
 
@@ -274,7 +277,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       transition.toProvable()
     );
 
-    const hashList = new DefaultProvableHashList(
+    const hashList = new StateTransitionReductionList(
       ProvableStateTransition,
       stateTransitionProof.publicInput.protocolTransitionsHash
     );
@@ -289,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();
 
@@ -356,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,
@@ -369,7 +371,9 @@ export class BlockProverProgrammable extends ZkProgrammable<
     // Append tx to incomingMessagesHash
     const actionHash = MinaActions.actionHash(transaction.hashData());
 
-    const incomingMessagesList = new MinaActionsHashList(state.incomingMessagesHash);
+    const incomingMessagesList = new MinaActionsHashList(
+      state.incomingMessagesHash
+    );
     incomingMessagesList.pushIf(actionHash, isMessage);
 
     stateTo.incomingMessagesHash = incomingMessagesList.commitment;
@@ -378,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,
     };
@@ -399,7 +403,7 @@ export class BlockProverProgrammable extends ZkProgrammable<
       executionData.transaction
     );
 
-    const stateTo = this.applyTransaction(
+    const stateTo = await this.applyTransaction(
       bundleInclusionState,
       stateProof,
       runtimeProof,
@@ -434,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,
     };
@@ -500,13 +504,13 @@ export class BlockProverProgrammable extends ZkProgrammable<
     transactionProof.verifyIf(verifyTransactionProof);
 
     // 2. Execute beforeBlock hooks
-    const beforeBlockResult = this.executeBlockHooks(
+    const beforeBlockResult = await this.executeBlockHooks(
       state,
       networkState,
       "beforeBlock"
     );
 
-    const beforeBlockHashList = new DefaultProvableHashList(
+    const beforeBlockHashList = new StateTransitionReductionList(
       ProvableStateTransition
     );
     beforeBlockResult.stateTransitions.forEach((st) => {
@@ -548,13 +552,13 @@ 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"
     );
 
-    const afterBlockHashList = new DefaultProvableHashList(
+    const afterBlockHashList = new StateTransitionReductionList(
       ProvableStateTransition
     );
     afterBlockResult.stateTransitions.forEach((st) => {
@@ -568,7 +572,11 @@ export class BlockProverProgrammable extends ZkProgrammable<
       afterBlockHashList.commitment,
       "STProof from-ST-hash not matching generated ST-hash from afterBlock hooks"
     );
-    state.stateRoot = stateTransitionProof.publicInput.stateRoot;
+    state.stateRoot = Provable.if(
+      stsEmitted,
+      stateTransitionProof.publicOutput.stateRoot,
+      state.stateRoot
+    );
 
     // 6. Close block
 
@@ -598,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();
 
@@ -744,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,
 
@@ -758,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,
@@ -773,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);
           },
         },
       },
@@ -795,11 +829,12 @@ 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),
       verify: program.verify.bind(program),
+      analyzeMethods: program.analyzeMethods.bind(program),
       Proof: SelfProofClass,
       methods,
     };
@@ -843,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,
@@ -858,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,
@@ -872,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,7 +1,7 @@
 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(16) {}
+export class BlockHashMerkleTree extends createMerkleTree(40) {}
 export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {}
 
 export class BlockHashTreeEntry extends Struct({

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>;
 }

package/src/prover/statetransition/StateTransitionProver.ts

@@ -1,34 +1,33 @@
-/* eslint-disable max-lines */
-import { Bool, Experimental, Field, Provable, SelfProof } from "o1js";
-import { injectable } from "tsyringe";
 import {
   AreProofsEnabled,
-  log,
   PlainZkProgram,
   provableMethod,
   RollupMerkleTreeWitness,
   ZkProgrammable,
 } from "@proto-kit/common";
+import { Field, Provable, SelfProof, ZkProgram } from "o1js";
+import { injectable } from "tsyringe";
 
-import {
-  DefaultProvableHashList,
-  ProvableHashList,
-} from "../../utils/ProvableHashList";
+import { constants } from "../../Constants";
 import { ProvableStateTransition } from "../../model/StateTransition";
 import {
   ProvableStateTransitionType,
   StateTransitionProvableBatch,
 } from "../../model/StateTransitionProvableBatch";
-import { constants } from "../../Constants";
+import { StateTransitionProverType } from "../../protocol/Protocol";
 import { ProtocolModule } from "../../protocol/ProtocolModule";
+import {
+  DefaultProvableHashList,
+  ProvableHashList,
+} from "../../utils/ProvableHashList";
 
-import { StateTransitionWitnessProvider } from "./StateTransitionWitnessProvider";
 import {
+  StateTransitionProof,
   StateTransitionProvable,
   StateTransitionProverPublicInput,
-  StateTransitionProof,
   StateTransitionProverPublicOutput,
 } from "./StateTransitionProvable";
+import { StateTransitionWitnessProvider } from "./StateTransitionWitnessProvider";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
 
 const errors = {
@@ -65,7 +64,6 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
   StateTransitionProverPublicOutput
 > {
   public constructor(
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
     private readonly stateTransitionProver: StateTransitionProver,
     public readonly witnessProviderReference: StateTransitionWitnessProviderReference
   ) {
@@ -80,11 +78,10 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
     StateTransitionProverPublicInput,
     StateTransitionProverPublicOutput
   > {
-    // eslint-disable-next-line max-len
-    // eslint-disable-next-line @typescript-eslint/no-this-alias,consistent-this,unicorn/no-this-assignment
     const instance = this;
 
-    const program = Experimental.ZkProgram({
+    const program = ZkProgram({
+      name: "StateTransitionProver",
       publicInput: StateTransitionProverPublicInput,
       publicOutput: StateTransitionProverPublicOutput,
 
@@ -92,11 +89,11 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
         proveBatch: {
           privateInputs: [StateTransitionProvableBatch],
 
-          method(
+          async method(
             publicInput: StateTransitionProverPublicInput,
             batch: StateTransitionProvableBatch
           ) {
-            return instance.runBatch(publicInput, batch);
+            return await instance.runBatch(publicInput, batch);
           },
         },
 
@@ -106,12 +103,12 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
             StateTransitionSelfProofClass,
           ],
 
-          method(
+          async method(
             publicInput: StateTransitionProverPublicInput,
             proof1: StateTransitionProof,
             proof2: StateTransitionProof
           ) {
-            return instance.merge(publicInput, proof1, proof2);
+            return await instance.merge(publicInput, proof1, proof2);
           },
         },
       },
@@ -122,11 +119,12 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
       merge: program.merge.bind(program),
     };
 
-    const SelfProofClass = Experimental.ZkProgram.Proof(program);
+    const SelfProofClass = ZkProgram.Proof(program);
 
     return {
       compile: program.compile.bind(program),
       verify: program.verify.bind(program),
+      analyzeMethods: program.analyzeMethods.bind(program),
       Proof: SelfProofClass,
       methods,
     };
@@ -240,10 +238,10 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
    * Applies a whole batch of StateTransitions at once
    */
   @provableMethod()
-  public runBatch(
+  public async runBatch(
     publicInput: StateTransitionProverPublicInput,
     batch: StateTransitionProvableBatch
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     const result = this.applyTransitions(
       publicInput.stateRoot,
       publicInput.protocolStateRoot,
@@ -261,11 +259,11 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
   }
 
   @provableMethod()
-  public merge(
+  public async merge(
     publicInput: StateTransitionProverPublicInput,
     proof1: StateTransitionProof,
     proof2: StateTransitionProof
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     proof1.verify();
     proof2.verify();
 
@@ -339,9 +337,9 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
 @injectable()
 export class StateTransitionProver
   extends ProtocolModule
-  implements StateTransitionProvable
+  implements StateTransitionProvable, StateTransitionProverType
 {
-  public readonly zkProgrammable: StateTransitionProverProgrammable;
+  public zkProgrammable: StateTransitionProverProgrammable;
 
   public constructor(
     // Injected
@@ -357,7 +355,7 @@ export class StateTransitionProver
   public runBatch(
     publicInput: StateTransitionProverPublicInput,
     batch: StateTransitionProvableBatch
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     return this.zkProgrammable.runBatch(publicInput, batch);
   }
 
@@ -365,7 +363,7 @@ export class StateTransitionProver
     publicInput: StateTransitionProverPublicInput,
     proof1: StateTransitionProof,
     proof2: StateTransitionProof
-  ): StateTransitionProverPublicOutput {
+  ): Promise<StateTransitionProverPublicOutput> {
     return this.zkProgrammable.merge(publicInput, proof1, proof2);
   }
 }

package/src/settlement/ContractModule.ts

@@ -0,0 +1,24 @@
+import { ConfigurableModule, NoConfig, TypedClass } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+
+export type SmartContractClassFromInterface<Type> = typeof SmartContract &
+  TypedClass<Type>;
+
+/**
+ * This module type is used to define a contract module that can be used to
+ * construct and inject smart contract instances.
+ * It defines a method contractFactory, whose arguments can be configured via
+ * the Argument generic. It returns a smart contract class that is a subclass
+ * of SmartContract and implements a certain interface as specified by the
+ * ContractType generic.
+ */
+export abstract class ContractModule<
+  ContractType,
+  // undefined = no args
+  Arguments = undefined,
+  Config = NoConfig,
+> extends ConfigurableModule<Config> {
+  public abstract contractFactory(
+    args: Arguments
+  ): SmartContractClassFromInterface<ContractType>;
+}