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

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

@@ -0,0 +1,16 @@
+import { createMerkleTree } from "@proto-kit/common";
+import { Bool, Field, Poseidon, Provable, Struct } from "o1js";
+
+export class BlockHashMerkleTree extends createMerkleTree(40) {}
+export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {}
+
+export class BlockHashTreeEntry extends Struct({
+  blockHash: Field,
+  closed: Bool,
+  // TODO We could add startingEternalTransactionsHash here to offer
+  // a more trivial connection to the sequence state
+}) {
+  public hash(): Field {
+    return Poseidon.hash([this.blockHash, ...this.closed.toFields()]);
+  }
+}

package/src/prover/statetransition/StateTransitionProver.ts

@@ -30,6 +30,7 @@ import {
   StateTransitionProverPublicOutput,
 } from "./StateTransitionProvable";
 import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import { StateTransitionProverType } from "../../protocol/Protocol";
 
 const errors = {
   propertyNotMatching: (property: string, step: string) =>
@@ -127,6 +128,7 @@ export class StateTransitionProverProgrammable extends ZkProgrammable<
     return {
       compile: program.compile.bind(program),
       verify: program.verify.bind(program),
+      analyzeMethods: program.analyzeMethods.bind(program),
       Proof: SelfProofClass,
       methods,
     };
@@ -339,9 +341,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

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

package/src/settlement/SettlementContractModule.ts

@@ -0,0 +1,127 @@
+import {
+  AreProofsEnabled,
+  ChildContainerProvider,
+  ModuleContainer,
+  ModulesRecord, ResolvableModules, StringKeyOf,
+  TypedClass
+} from "@proto-kit/common";
+import { PublicKey, SmartContract } from "o1js";
+import { injectable } from "tsyringe";
+
+import { ProtocolEnvironment } from "../protocol/ProtocolEnvironment";
+import { ProtocolModule } from "../protocol/ProtocolModule";
+
+import {
+  ContractModule,
+  SmartContractClassFromInterface,
+} from "./ContractModule";
+import { DispatchContractProtocolModule } from "./contracts/DispatchContractProtocolModule";
+import { DispatchContractType } from "./contracts/DispatchSmartContract";
+import {
+  SettlementContractConfig,
+  SettlementContractProtocolModule,
+} from "./contracts/SettlementContractProtocolModule";
+import { SettlementContractType } from "./contracts/SettlementSmartContract";
+
+export type SettlementModulesRecord = ModulesRecord<
+  TypedClass<ContractModule<unknown, unknown, unknown>>
+>;
+
+export type MandatorySettlementModulesRecord = {
+  SettlementContract: TypedClass<
+    ContractModule<
+      SettlementContractType,
+      SmartContractClassFromInterface<DispatchContractType>,
+      SettlementContractConfig
+    >
+  >;
+  DispatchContract: TypedClass<
+    ContractModule<DispatchContractType, unknown, unknown>
+  >;
+};
+
+@injectable()
+export class SettlementContractModule<
+    SettlementModules extends SettlementModulesRecord &
+      MandatorySettlementModulesRecord
+  >
+  extends ModuleContainer<SettlementModules>
+  implements ProtocolModule<unknown>
+{
+  public constructor(definition: { modules: SettlementModules }) {
+    super(definition);
+  }
+
+  public static from<
+    SettlementModules extends SettlementModulesRecord &
+      MandatorySettlementModulesRecord
+  >(
+    modules: SettlementModules
+  ): TypedClass<SettlementContractModule<SettlementModules>> {
+    return class ScopedSettlementContractModule extends SettlementContractModule<SettlementModules> {
+      public constructor() {
+        super({ modules });
+      }
+    };
+  }
+
+  public static fromDefaults() {
+    return SettlementContractModule.from({
+      SettlementContract: SettlementContractProtocolModule,
+      DispatchContract: DispatchContractProtocolModule,
+    });
+  }
+
+  // ** For protocol module
+  public protocol?: ProtocolEnvironment;
+
+  public get appChain(): AreProofsEnabled | undefined {
+    return this.protocol?.getAreProofsEnabled();
+  }
+  // **
+
+  public create(childContainerProvider: ChildContainerProvider) {
+    super.create(childContainerProvider);
+  }
+
+  // private assertIsKeyofModules
+
+  public getContractClasses(): {
+    settlement: SmartContractClassFromInterface<SettlementContractType>;
+    dispatch: SmartContractClassFromInterface<DispatchContractType>;
+  } {
+    const settlementContractKey = "SettlementContract"
+    const dispatchContractKey = "DispatchContract"
+    this.assertIsValidModuleName(settlementContractKey)
+    this.assertIsValidModuleName(dispatchContractKey)
+
+    const settlementModule = this.resolve(settlementContractKey);
+    const dispatchModule = this.resolve(dispatchContractKey);
+
+    const dispatch = dispatchModule.contractFactory(undefined);
+    const settlement = settlementModule.contractFactory(dispatch);
+
+    return {
+      settlement,
+      dispatch,
+    };
+  }
+
+  public createContracts(addresses: {
+    settlement: PublicKey;
+    dispatch: PublicKey;
+  }): {
+    settlement: SettlementContractType & SmartContract;
+    dispatch: DispatchContractType & SmartContract;
+  } {
+    const { dispatch, settlement } = this.getContractClasses();
+
+    const dispatchInstance = new dispatch(addresses.dispatch);
+    const settlementInstance = new settlement(addresses.settlement);
+
+    return {
+      dispatch: dispatchInstance,
+      settlement: settlementInstance,
+    };
+  }
+}

package/src/settlement/contracts/DispatchContractProtocolModule.ts

@@ -0,0 +1,39 @@
+import { inject, injectable } from "tsyringe";
+
+import { RuntimeLike } from "../../model/RuntimeLike";
+import {
+  ContractModule,
+  SmartContractClassFromInterface,
+} from "../ContractModule";
+
+import {
+  DispatchSmartContract,
+  DispatchContractType,
+} from "./DispatchSmartContract";
+
+export type DispatchContractConfig = {
+  incomingMessagesMethods: Record<string, `${string}.${string}`>;
+};
+
+@injectable()
+export class DispatchContractProtocolModule extends ContractModule<
+  DispatchContractType,
+  undefined,
+  DispatchContractConfig
+> {
+  public constructor(@inject("Runtime") private readonly runtime: RuntimeLike) {
+    super();
+  }
+
+  public contractFactory(): SmartContractClassFromInterface<DispatchContractType> {
+    const { incomingMessagesMethods } = this.config;
+    const methodIdMappings = this.runtime.methodIdResolver.methodIdMap();
+
+    DispatchSmartContract.args = {
+      incomingMessagesPaths: incomingMessagesMethods,
+      methodIdMappings,
+    };
+
+    return DispatchSmartContract;
+  }
+}

package/src/settlement/contracts/DispatchSmartContract.ts

@@ -0,0 +1,135 @@
+import {
+  AccountUpdate,
+  Field,
+  method,
+  Poseidon,
+  ProvableExtended,
+  PublicKey,
+  Reducer,
+  SmartContract,
+  State,
+  state,
+  UInt64,
+} from "o1js";
+
+import { RuntimeMethodIdMapping } from "../../model/RuntimeLike";
+import { RuntimeTransaction } from "../../model/transaction/RuntimeTransaction";
+import {
+  MinaActions,
+  MinaEvents,
+} from "../../utils/MinaPrefixedProvableHashList";
+import { Deposit } from "../messages/Deposit";
+
+export const ACTIONS_EMPTY_HASH = Reducer.initialActionState;
+
+export interface DispatchContractType {
+  updateMessagesHash: (
+    executedMessagesHash: Field,
+    newPromisedMessagesHash: Field
+  ) => void;
+  initialize: (settlementContract: PublicKey) => void;
+
+  promisedMessagesHash: State<Field>;
+}
+
+export class DispatchSmartContract
+  extends SmartContract
+  implements DispatchContractType
+{
+  public static args: {
+    methodIdMappings: RuntimeMethodIdMapping;
+    incomingMessagesPaths: Record<string, `${string}.${string}`>;
+  };
+
+  @state(Field) public promisedMessagesHash = State<Field>();
+
+  @state(Field) public honoredMessagesHash = State<Field>();
+
+  @state(PublicKey) public settlementContract = State<PublicKey>();
+
+  @method
+  public updateMessagesHash(
+    executedMessagesHash: Field,
+    newPromisedMessagesHash: Field
+  ) {
+    const promisedMessagesHash = this.promisedMessagesHash.getAndAssertEquals();
+    this.honoredMessagesHash.getAndAssertEquals();
+
+    executedMessagesHash.assertEquals(promisedMessagesHash);
+
+    this.honoredMessagesHash.set(executedMessagesHash);
+
+    // Assert and apply new promisedMessagesHash
+    this.self.account.actionState.assertEquals(newPromisedMessagesHash);
+    this.promisedMessagesHash.set(newPromisedMessagesHash);
+  }
+
+  @method
+  public initialize(settlementContract: PublicKey) {
+    this.promisedMessagesHash.getAndAssertEquals().assertEquals(Field(0));
+    this.honoredMessagesHash.getAndAssertEquals().assertEquals(Field(0));
+    this.settlementContract
+      .getAndAssertEquals()
+      .assertEquals(PublicKey.empty());
+
+    this.promisedMessagesHash.set(ACTIONS_EMPTY_HASH);
+    this.honoredMessagesHash.set(ACTIONS_EMPTY_HASH);
+    this.settlementContract.set(settlementContract);
+  }
+
+  private dispatchMessage<Type>(
+    methodId: Field,
+    value: Type,
+    valueType: ProvableExtended<Type>
+  ) {
+    const args = valueType.toFields(value);
+    // Should be the same as RuntimeTransaction.hash
+    const argsHash = Poseidon.hash(args);
+    const runtimeTransaction = RuntimeTransaction.fromMessage({
+      methodId,
+      argsHash,
+    });
+
+    // Append tx to incomingMessagesHash
+    const actionData = runtimeTransaction.hashData();
+    const actionHash = MinaActions.actionHash(actionData);
+
+    this.self.body.actions = {
+      hash: actionHash,
+      data: [actionData],
+    };
+
+    const eventHash = MinaEvents.eventHash(args);
+    this.self.body.events = {
+      hash: eventHash,
+      data: [args],
+    };
+  }
+
+  @method
+  public deposit(amount: UInt64) {
+    // Save this, since otherwise it would be a second witness later,
+    // which could be a different values than the first
+    const { sender } = this;
+
+    const settlementContract = this.settlementContract.getAndAssertEquals();
+
+    // Credit the amount to the settlement contract
+    const balanceAU = AccountUpdate.create(settlementContract);
+    balanceAU.balance.addInPlace(amount);
+    this.self.approve(balanceAU);
+
+    const action = new Deposit({
+      address: sender,
+      amount,
+    });
+
+    const { methodIdMappings, incomingMessagesPaths } =
+      DispatchSmartContract.args;
+
+    const methodId = Field(
+      methodIdMappings[incomingMessagesPaths.deposit].methodId
+    ).toConstant();
+    this.dispatchMessage(methodId.toConstant(), action, Deposit);
+  }
+}

package/src/settlement/contracts/SettlementContractProtocolModule.ts

@@ -0,0 +1,65 @@
+import { TypedClass } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+import { inject, injectable, injectAll } from "tsyringe";
+
+import { BlockProvable } from "../../prover/block/BlockProvable";
+import {
+  ContractModule,
+  SmartContractClassFromInterface,
+} from "../ContractModule";
+import { ProvableSettlementHook } from "../modularity/ProvableSettlementHook";
+
+import { DispatchContractType } from "./DispatchSmartContract";
+import {
+  LazyBlockProof,
+  SettlementContractType,
+  SettlementSmartContract,
+} from "./SettlementSmartContract";
+
+export type SettlementContractConfig = {
+  escapeHatchSlotsInterval?: number;
+  withdrawalStatePath: `${string}.${string}`;
+  withdrawalMethodPath: `${string}.${string}`;
+};
+
+// 24 hours
+const DEFAULT_ESCAPE_HATCH = (60 / 3) * 24;
+
+@injectable()
+export class SettlementContractProtocolModule extends ContractModule<
+  SettlementContractType,
+  TypedClass<DispatchContractType & SmartContract>,
+  SettlementContractConfig
+> {
+  public constructor(
+    @injectAll("ProvableSettlementHook")
+    private readonly hooks: ProvableSettlementHook<unknown>[],
+    @inject("BlockProver")
+    private readonly blockProver: BlockProvable
+  ) {
+    LazyBlockProof.tag = blockProver.zkProgrammable.zkProgram.Proof.tag;
+    super();
+  }
+
+  public contractFactory(
+    dispatchContract: TypedClass<DispatchContractType & SmartContract>
+  ): SmartContractClassFromInterface<SettlementContractType> {
+    const { hooks, config } = this;
+
+    const withdrawalStatePathSplit = this.config.withdrawalStatePath.split(
+      "."
+    ) as [string, string];
+
+    const escapeHatchSlotsInterval =
+      this.config.escapeHatchSlotsInterval ?? DEFAULT_ESCAPE_HATCH;
+
+    SettlementSmartContract.args = {
+      DispatchContract: dispatchContract,
+      hooks,
+      withdrawalStatePath: withdrawalStatePathSplit,
+      escapeHatchSlotsInterval,
+    };
+
+    return SettlementSmartContract;
+  }
+}