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

package/src/model/transaction/SignedTransaction.ts

@@ -0,0 +1,54 @@
+import {
+  Bool,
+  Field,
+  Scalar,
+  Signature,
+  Struct,
+  UInt64,
+} from "o1js";
+
+import { RuntimeTransaction } from "./RuntimeTransaction";
+
+export class SignedTransaction extends Struct({
+  transaction: RuntimeTransaction,
+  signature: Signature,
+}) {
+  public static getSignatureData(args: {
+    methodId: Field;
+    nonce: UInt64;
+    argsHash: Field;
+  }): Field[] {
+    return [args.methodId, ...args.nonce.value.toFields(), args.argsHash];
+  }
+
+  public static dummy(): SignedTransaction {
+    return new SignedTransaction({
+      transaction: RuntimeTransaction.dummyTransaction(),
+
+      signature: Signature.fromObject({
+        s: Scalar.from(0),
+        r: Field(0),
+      }),
+    });
+  }
+
+  public hash(): Field {
+    return this.transaction.hash();
+  }
+
+  public getSignatureData(): Field[] {
+    const { methodId, argsHash, nonce } = this.transaction;
+    return SignedTransaction.getSignatureData({
+      nonce: nonce.value,
+      methodId,
+      argsHash,
+    });
+  }
+
+  public validateSignature(): Bool {
+    return this.signature.verify(
+      this.transaction.sender.value,
+      this.getSignatureData()
+    );
+  }
+}

package/src/model/transaction/ValueOption.ts

@@ -0,0 +1,28 @@
+import { Bool, ProvableExtended, PublicKey, Struct, UInt64 } from "o1js";
+
+function genericOptionFactory<Type>(valueType: ProvableExtended<Type>) {
+  return class Generic extends Struct({
+    isSome: Bool,
+    value: valueType,
+  }) {
+    public static fromValue(value: Type) {
+      return new Generic({
+        isSome: Bool(true),
+        value,
+      });
+    }
+
+    public static none(value: Type) {
+      return new Generic({
+        isSome: Bool(false),
+        value,
+      });
+    }
+  };
+}
+
+export class UInt64Option extends genericOptionFactory<UInt64>(UInt64) {}
+
+export class PublicKeyOption extends genericOptionFactory<PublicKey>(
+  PublicKey
+) {}

package/src/protocol/Protocol.ts

@@ -25,10 +25,14 @@ 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 = {
+const PROTOCOL_INJECTION_TOKENS: Record<string, string> = {
   ProvableTransactionHook: "ProvableTransactionHook",
   ProvableBlockHook: "ProvableBlockHook",
+  ProvableSettlementHook: "ProvableSettlementHook",
 };
 
 export type GenericProtocolModuleRecord = ModulesRecord<
@@ -41,10 +45,13 @@ interface StateTransitionProverType
   extends ProtocolModule,
     StateTransitionProvable {}
 
-export interface ProtocolCustomModulesRecord {
+export interface ProtocolCustomModulesRecord
+  extends GenericProtocolModuleRecord {
   BlockProver: TypedClass<BlockProverType>;
   StateTransitionProver: TypedClass<StateTransitionProverType>;
   AccountState: TypedClass<AccountStateModule>;
+  BlockHeight: TypedClass<BlockHeightHook>;
+  LastStateRoot: TypedClass<LastStateRootBlockHook>;
 }
 
 export interface ProtocolModulesRecord
@@ -133,42 +140,52 @@ export class Protocol<Modules extends ProtocolModulesRecord>
 
     // Register the BlockModules seperately since we need to
     // inject them differently later
-    let atLeastOneTransactionHookRegistered = false;
-    let atLeastOneBlockHookRegistered = false;
-    Object.entries(this.definition.modules).forEach(([key, value]) => {
-      if (Object.prototype.isPrototypeOf.call(ProvableTransactionHook, value)) {
+    const ABSTRACT_MODULE_TYPES = [
+      { type: ProvableTransactionHook, defaultType: NoopTransactionHook },
+      { type: ProvableBlockHook, defaultType: NoopBlockHook },
+      { type: ProvableSettlementHook, defaultType: NoopSettlementHook },
+    ] as const;
+
+    ABSTRACT_MODULE_TYPES.forEach((moduleTypeRegistration) => {
+      const abstractType = moduleTypeRegistration.type;
+
+      const implementingModules = Object.entries(
+        this.definition.modules
+      ).filter(([, value]) =>
+        Object.prototype.isPrototypeOf.call(abstractType, value)
+      );
+
+      const newInjectionToken: string | undefined =
+        PROTOCOL_INJECTION_TOKENS[abstractType.name];
+
+      if (newInjectionToken === undefined) {
+        log.error(
+          "Can't inject hook under the underlying hook token: Alias not found in mapping"
+        );
+        return;
+      }
+
+      implementingModules.forEach(([key]) => {
         this.container.register(
-          PROTOCOL_INJECTION_TOKENS.ProvableTransactionHook,
+          abstractType.name,
           { useToken: key },
           { lifecycle: Lifecycle.ContainerScoped }
         );
-        atLeastOneTransactionHookRegistered = true;
-      }
-      if (Object.prototype.isPrototypeOf.call(ProvableBlockHook, value)) {
+      });
+      if (implementingModules.length === 0) {
+        // This type annotation shouldn't change anything but is necessary
+        // bcs tsyringe complains
+        const { defaultType }: { defaultType: TypedClass<unknown> } =
+          moduleTypeRegistration;
+
+        // Register default (noop) version
         this.container.register(
-          PROTOCOL_INJECTION_TOKENS.ProvableBlockHook,
-          { useToken: key },
+          abstractType.name,
+          { useClass: defaultType },
           { lifecycle: Lifecycle.ContainerScoped }
         );
-        atLeastOneBlockHookRegistered = true;
       }
     });
-
-    // We need this so that tsyringe doesn't throw when no hooks are registered
-    if (!atLeastOneTransactionHookRegistered) {
-      this.container.register(
-        PROTOCOL_INJECTION_TOKENS.ProvableTransactionHook,
-        { useClass: NoopTransactionHook },
-        { lifecycle: Lifecycle.ContainerScoped }
-      );
-    }
-    if (!atLeastOneBlockHookRegistered) {
-      this.container.register(
-        PROTOCOL_INJECTION_TOKENS.ProvableBlockHook,
-        { useClass: NoopBlockHook },
-        { lifecycle: Lifecycle.ContainerScoped }
-      );
-    }
   }
 }
 
@@ -179,13 +196,14 @@ export const VanillaProtocol = {
 
   from<AdditonalModules extends GenericProtocolModuleRecord>(
     additionalModules: AdditonalModules
-  ): TypedClass<Protocol<ProtocolModulesRecord>> {
-    return Protocol.from<ProtocolModulesRecord>({
+  ): TypedClass<Protocol<ProtocolCustomModulesRecord & AdditonalModules>> {
+    return Protocol.from<ProtocolCustomModulesRecord & AdditonalModules>({
       modules: {
         StateTransitionProver,
         BlockProver,
         AccountState: AccountStateModule,
         BlockHeight: BlockHeightHook,
+        LastStateRoot: LastStateRootBlockHook,
         ...additionalModules,
       },
     });

package/src/protocol/ProvableBlockHook.ts

@@ -3,20 +3,17 @@ import { NetworkState } from "../model/network/NetworkState";
 
 import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
 
-export interface BeforeBlockParameters {
-  state: BlockProverState;
-  networkState: NetworkState;
-}
-
-export interface AfterBlockParameters {
-  state: BlockProverState;
-  networkState: NetworkState;
-}
-
-// Purpose is to validate transition from -> to network state
+// Purpose is to build transition from -> to network state
 export abstract class ProvableBlockHook<
   Config
 > extends TransitioningProtocolModule<Config> {
-  public abstract beforeBlock(blockData: BeforeBlockParameters): NetworkState;
-  public abstract afterBlock(blockData: AfterBlockParameters): NetworkState;
+  public abstract beforeBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): NetworkState;
+
+  public abstract afterBlock(
+    networkState: NetworkState,
+    state: BlockProverState
+  ): NetworkState;
 }

package/src/protocol/ProvableTransactionHook.ts

@@ -1,7 +1,8 @@
+import { NoConfig } from "@proto-kit/common";
+
 import { BlockProverExecutionData } from "../prover/block/BlockProvable";
 
 import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
-import { NoConfig } from "@proto-kit/common";
 
 export abstract class ProvableTransactionHook<
   Config = NoConfig

package/src/protocol/TransitioningProtocolModule.ts

@@ -1,8 +1,9 @@
 import { ProtocolModule } from "./ProtocolModule";
 
 /**
- * A Protocolmodule that enables it's implementing module to access to
- * StateTransitions and state
+ * 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

package/src/prover/block/BlockProvable.ts

@@ -1,23 +1,48 @@
-import { Bool, Field, Proof, Struct } from "o1js";
+import { Bool, Field, Proof, Signature, Struct } from "o1js";
 import { WithZkProgrammable } from "@proto-kit/common";
 
 import { StateTransitionProof } from "../statetransition/StateTransitionProvable";
 import { MethodPublicOutput } from "../../model/MethodPublicOutput";
-import { ProtocolTransaction } from "../../model/transaction/ProtocolTransaction";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
 import { NetworkState } from "../../model/network/NetworkState";
-import { BlockTransactionPosition } from "./BlockTransactionPosition";
+
+import { BlockHashMerkleTreeWitness } from "./accummulators/BlockHashMerkleTree";
 
 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,
@@ -25,9 +50,9 @@ export type BlockProverProof = Proof<
 >;
 
 export class BlockProverExecutionData extends Struct({
-  transaction: ProtocolTransaction,
+  transaction: RuntimeTransaction,
+  signature: Signature,
   networkState: NetworkState,
-  transactionPosition: BlockTransactionPosition,
 }) {}
 
 export interface BlockProvable
@@ -39,6 +64,14 @@ export interface BlockProvable
     executionData: BlockProverExecutionData
   ) => BlockProverPublicOutput;
 
+  proveBlock: (
+    publicInput: BlockProverPublicInput,
+    networkState: NetworkState,
+    blockWitness: BlockHashMerkleTreeWitness,
+    stateTransitionProof: StateTransitionProof,
+    transactionProof: BlockProverProof
+  ) => BlockProverPublicOutput;
+
   merge: (
     publicInput: BlockProverPublicInput,
     proof1: BlockProverProof,