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

package/src/settlement/contracts/SettlementSmartContract.ts

@@ -0,0 +1,350 @@
+import {
+  prefixToField,
+  RollupMerkleTree,
+  TypedClass,
+  mapSequential,
+} from "@proto-kit/common";
+import {
+  AccountUpdate,
+  Bool,
+  Field,
+  method,
+  Mina,
+  Poseidon,
+  Proof,
+  Provable,
+  PublicKey,
+  Signature,
+  SmartContract,
+  State,
+  state,
+  TokenId,
+  UInt32,
+  UInt64,
+  TokenContract,
+  AccountUpdateForest,
+} from "o1js";
+
+import { NetworkState } from "../../model/network/NetworkState";
+import { Path } from "../../model/Path";
+import { BlockHashMerkleTree } from "../../prover/block/accummulators/BlockHashMerkleTree";
+import {
+  BlockProverPublicInput,
+  BlockProverPublicOutput,
+} from "../../prover/block/BlockProvable";
+import {
+  OUTGOING_MESSAGE_BATCH_SIZE,
+  OutgoingMessageArgumentBatch,
+} from "../messages/OutgoingMessageArgument";
+import { Withdrawal } from "../messages/Withdrawal";
+import {
+  ProvableSettlementHook,
+  SettlementHookInputs,
+  SettlementStateRecord,
+} from "../modularity/ProvableSettlementHook";
+
+import { DispatchContractType } from "./DispatchSmartContract";
+
+/* eslint-disable @typescript-eslint/lines-between-class-members */
+
+export class LazyBlockProof extends Proof<
+  BlockProverPublicInput,
+  BlockProverPublicOutput
+> {
+  public static publicInputType = BlockProverPublicInput;
+
+  public static publicOutputType = BlockProverPublicOutput;
+
+  public static tag: () => { name: string } = () => {
+    throw new Error("Tag not initialized yet");
+  };
+}
+
+export interface SettlementContractType {
+  initialize: (
+    sequencer: PublicKey,
+    dispatchContract: PublicKey
+  ) => Promise<void>;
+  settle: (
+    blockProof: LazyBlockProof,
+    signature: Signature,
+    dispatchContractAddress: PublicKey,
+    publicKey: PublicKey,
+    inputNetworkState: NetworkState,
+    outputNetworkState: NetworkState,
+    newPromisedMessagesHash: Field
+  ) => Promise<void>;
+  rollupOutgoingMessages: (
+    batch: OutgoingMessageArgumentBatch
+  ) => Promise<void>;
+  redeem: (additionUpdate: AccountUpdate) => Promise<void>;
+}
+
+// Some random prefix for the sequencer signature
+export const BATCH_SIGNATURE_PREFIX = prefixToField("pk-batchSignature");
+
+export class SettlementSmartContract
+  extends TokenContract
+  implements SettlementContractType
+{
+  // This pattern of injecting args into a smartcontract is currently the only
+  // viable solution that works given the inheritance issues of o1js
+  public static args: {
+    DispatchContract: TypedClass<DispatchContractType & SmartContract>;
+    hooks: ProvableSettlementHook<unknown>[];
+    withdrawalStatePath: [string, string];
+    escapeHatchSlotsInterval: number;
+  };
+
+  @state(Field) public sequencerKey = State<Field>();
+  @state(UInt32) public lastSettlementL1Block = State<UInt32>();
+
+  @state(Field) public stateRoot = State<Field>();
+  @state(Field) public networkStateHash = State<Field>();
+  @state(Field) public blockHashRoot = State<Field>();
+
+  @state(Field) public dispatchContractAddressX = State<Field>();
+
+  @state(Field) public outgoingMessageCursor = State<Field>();
+
+  @method async approveBase(forest: AccountUpdateForest) {
+    this.checkZeroBalanceChange(forest);
+  }
+
+  @method
+  public async initialize(sequencer: PublicKey, dispatchContract: PublicKey) {
+    this.sequencerKey.getAndRequireEquals().assertEquals(Field(0));
+    this.stateRoot.getAndRequireEquals().assertEquals(Field(0));
+    this.blockHashRoot.getAndRequireEquals().assertEquals(Field(0));
+    this.networkStateHash.getAndRequireEquals().assertEquals(Field(0));
+    this.dispatchContractAddressX.getAndRequireEquals().assertEquals(Field(0));
+
+    this.sequencerKey.set(sequencer.x);
+    this.stateRoot.set(Field(RollupMerkleTree.EMPTY_ROOT));
+    this.blockHashRoot.set(Field(BlockHashMerkleTree.EMPTY_ROOT));
+    this.networkStateHash.set(NetworkState.empty().hash());
+    this.dispatchContractAddressX.set(dispatchContract.x);
+
+    const { DispatchContract } = SettlementSmartContract.args;
+    await new DispatchContract(dispatchContract).initialize(this.address);
+  }
+
+  @method
+  public async settle(
+    blockProof: LazyBlockProof,
+    signature: Signature,
+    dispatchContractAddress: PublicKey,
+    publicKey: PublicKey,
+    inputNetworkState: NetworkState,
+    outputNetworkState: NetworkState,
+    newPromisedMessagesHash: Field
+  ) {
+    // Verify the blockproof
+    blockProof.verify();
+
+    // Get and assert on-chain values
+    const stateRoot = this.stateRoot.getAndRequireEquals();
+    const networkStateHash = this.networkStateHash.getAndRequireEquals();
+    const blockHashRoot = this.blockHashRoot.getAndRequireEquals();
+    const sequencerKey = this.sequencerKey.getAndRequireEquals();
+    const lastSettlementL1Block =
+      this.lastSettlementL1Block.getAndRequireEquals();
+    const onChainDispatchContractAddressX =
+      this.dispatchContractAddressX.getAndRequireEquals();
+
+    onChainDispatchContractAddressX.assertEquals(
+      dispatchContractAddress.x,
+      "DispatchContract address not provided correctly"
+    );
+
+    const { DispatchContract, escapeHatchSlotsInterval, hooks } =
+      SettlementSmartContract.args;
+
+    // Get dispatch contract values
+    // These values are witnesses but will be checked later on the AU
+    // call to the dispatch contract via .updateMessagesHash()
+    const dispatchContract = new DispatchContract(dispatchContractAddress);
+    const promisedMessagesHash = dispatchContract.promisedMessagesHash.get();
+
+    // Get block height and use the lower bound for all ops
+    const minBlockIncluded = this.network.globalSlotSinceGenesis.get();
+    this.network.globalSlotSinceGenesis.requireBetween(
+      minBlockIncluded,
+      // 5 because that is the length the newPromisedMessagesHash will be valid
+      minBlockIncluded.add(4)
+    );
+
+    // Check signature/escape catch
+    publicKey.x.assertEquals(
+      sequencerKey,
+      "Sequencer public key witness not matching"
+    );
+    const signatureValid = signature.verify(publicKey, [
+      BATCH_SIGNATURE_PREFIX,
+      lastSettlementL1Block.value,
+    ]);
+    const escapeHatchActivated = lastSettlementL1Block
+      .add(UInt32.from(escapeHatchSlotsInterval))
+      .lessThan(minBlockIncluded);
+    signatureValid
+      .or(escapeHatchActivated)
+      .assertTrue(
+        "Sequencer signature not valid and escape hatch not activated"
+      );
+
+    // Assert correctness of networkState witness
+    Provable.log("Network State Hash ", networkStateHash);
+    Provable.log("input Hash ", inputNetworkState.hash());
+    Provable.log("equals ", inputNetworkState.hash().equals(networkStateHash));
+
+    inputNetworkState
+      .hash()
+      .assertEquals(networkStateHash, "InputNetworkState witness not valid");
+    outputNetworkState
+      .hash()
+      .assertEquals(
+        blockProof.publicOutput.networkStateHash,
+        "OutputNetworkState witness not valid"
+      );
+
+    blockProof.publicOutput.closed.assertEquals(
+      Bool(true),
+      "Supplied proof is not a closed BlockProof"
+    );
+
+    // Execute onSettlementHooks for additional checks
+    const stateRecord: SettlementStateRecord = {
+      blockHashRoot,
+      stateRoot,
+      networkStateHash,
+      lastSettlementL1Block,
+      sequencerKey: publicKey,
+    };
+    const inputs: SettlementHookInputs = {
+      blockProof,
+      contractState: stateRecord,
+      newPromisedMessagesHash,
+      fromNetworkState: inputNetworkState,
+      toNetworkState: outputNetworkState,
+      currentL1Block: minBlockIncluded,
+    };
+    await mapSequential(hooks, async (hook) => {
+      await hook.beforeSettlement(this, inputs);
+    });
+
+    // Apply blockProof
+    stateRoot.assertEquals(
+      blockProof.publicInput.stateRoot,
+      "Input state root not matching"
+    );
+    Provable.log("Network State Hash ", networkStateHash);
+    Provable.log("input Hash ", inputNetworkState.hash());
+    Provable.log("Proof Hash ", blockProof.publicInput.networkStateHash);
+
+    networkStateHash.assertEquals(
+      blockProof.publicInput.networkStateHash,
+      "Input networkStateHash not matching"
+    );
+    blockHashRoot.assertEquals(
+      blockProof.publicInput.blockHashRoot,
+      "Input blockHashRoot not matching"
+    );
+    this.stateRoot.set(blockProof.publicOutput.stateRoot);
+    this.networkStateHash.set(blockProof.publicOutput.networkStateHash);
+    this.blockHashRoot.set(blockProof.publicOutput.blockHashRoot);
+
+    // Assert and apply deposit commitments
+    promisedMessagesHash.assertEquals(
+      blockProof.publicOutput.incomingMessagesHash,
+      "Promised messages not honored"
+    );
+
+    // Call DispatchContract
+    // This call checks that the promisedMessagesHash, which is already proven
+    // to be the blockProofs publicoutput, is actually the current on-chain
+    // promisedMessageHash. It also checks the newPromisedMessagesHash to be
+    // a current sequencestate value
+    await dispatchContract.updateMessagesHash(
+      promisedMessagesHash,
+      newPromisedMessagesHash
+    );
+
+    this.lastSettlementL1Block.set(minBlockIncluded);
+  }
+
+  @method
+  public async rollupOutgoingMessages(batch: OutgoingMessageArgumentBatch) {
+    let counter = this.outgoingMessageCursor.getAndRequireEquals();
+    const stateRoot = this.stateRoot.getAndRequireEquals();
+
+    const [withdrawalModule, withdrawalStateName] =
+      SettlementSmartContract.args.withdrawalStatePath;
+    const mapPath = Path.fromProperty(withdrawalModule, withdrawalStateName);
+
+    let accountCreationFeePaid = Field(0);
+
+    for (let i = 0; i < OUTGOING_MESSAGE_BATCH_SIZE; i++) {
+      const args = batch.arguments[i];
+
+      // Check witness
+      const path = Path.fromKey(mapPath, Field, counter);
+
+      args.witness
+        .checkMembership(
+          stateRoot,
+          path,
+          Poseidon.hash(Withdrawal.toFields(args.value))
+        )
+        .assertTrue("Provided Withdrawal witness not valid");
+
+      // Process message
+      const { address, amount } = args.value;
+      const isDummy = address.equals(this.address);
+
+      const tokenAu = this.internal.mint({ address, amount });
+      const isNewAccount = tokenAu.account.isNew.getAndRequireEquals();
+      tokenAu.body.balanceChange.magnitude =
+        tokenAu.body.balanceChange.magnitude.sub(
+          Provable.if(
+            isNewAccount,
+            Mina.getNetworkConstants().accountCreationFee.toConstant(),
+            UInt64.zero
+          )
+        );
+
+      accountCreationFeePaid = accountCreationFeePaid.add(
+        Provable.if(isNewAccount, Field(1e9), Field(0))
+      );
+
+      counter = counter.add(Provable.if(isDummy, Field(0), Field(1)));
+    }
+
+    this.balance.subInPlace(UInt64.Unsafe.fromField(accountCreationFeePaid));
+
+    this.outgoingMessageCursor.set(counter);
+  }
+
+  @method
+  public async redeem(additionUpdate: AccountUpdate) {
+    additionUpdate.body.tokenId.assertEquals(
+      TokenId.default,
+      "Tokenid not default token"
+    );
+    additionUpdate.body.balanceChange.sgn
+      .isPositive()
+      .assertTrue("Sign not correct");
+    const amount = additionUpdate.body.balanceChange.magnitude;
+
+    // Burn tokens
+    this.internal.burn({
+      address: additionUpdate.publicKey,
+      amount,
+    });
+
+    // Send mina
+    this.approve(additionUpdate);
+    this.balance.subInPlace(amount);
+  }
+}
+
+/* eslint-enable @typescript-eslint/lines-between-class-members */

package/src/settlement/messages/Deposit.ts

@@ -0,0 +1,6 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+
+export class Deposit extends Struct({
+  address: PublicKey,
+  amount: UInt64,
+}) {}

package/src/settlement/messages/OutgoingMessageArgument.ts

@@ -0,0 +1,42 @@
+import { Bool, Provable, Struct } from "o1js";
+import { RollupMerkleTreeWitness } from "@proto-kit/common";
+
+import { Withdrawal } from "./Withdrawal";
+
+export const OUTGOING_MESSAGE_BATCH_SIZE = 1;
+
+export class OutgoingMessageArgument extends Struct({
+  witness: RollupMerkleTreeWitness,
+  value: Withdrawal,
+}) {
+  public static dummy(): OutgoingMessageArgument {
+    return new OutgoingMessageArgument({
+      witness: RollupMerkleTreeWitness.dummy(),
+      value: Withdrawal.dummy(),
+    });
+  }
+}
+
+export class OutgoingMessageArgumentBatch extends Struct({
+  arguments: Provable.Array(
+    OutgoingMessageArgument,
+    OUTGOING_MESSAGE_BATCH_SIZE
+  ),
+
+  isDummys: Provable.Array(Bool, OUTGOING_MESSAGE_BATCH_SIZE),
+}) {
+  public static fromMessages(providedArguments: OutgoingMessageArgument[]) {
+    const batch = providedArguments.slice();
+    const isDummys = batch.map(() => Bool(false));
+
+    while (batch.length < OUTGOING_MESSAGE_BATCH_SIZE) {
+      batch.push(OutgoingMessageArgument.dummy());
+      isDummys.push(Bool(true));
+    }
+
+    return new OutgoingMessageArgumentBatch({
+      arguments: batch,
+      isDummys,
+    });
+  }
+}

package/src/settlement/messages/Withdrawal.ts

@@ -0,0 +1,14 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+import { EMPTY_PUBLICKEY } from "@proto-kit/common";
+
+export class Withdrawal extends Struct({
+  address: PublicKey,
+  amount: UInt64,
+}) {
+  public static dummy() {
+    return new Withdrawal({
+      address: EMPTY_PUBLICKEY,
+      amount: UInt64.from(0),
+    });
+  }
+}

package/src/settlement/{ProvableSettlementHook.ts → modularity/ProvableSettlementHook.ts}

@@ -1,21 +1,17 @@
-import { Field, UInt32 } from "o1js";
+import { Field, PublicKey, UInt32 } from "o1js";
 
-import type { BlockProof } from "../prover/block/BlockProver";
-import { ProtocolModule } from "../protocol/ProtocolModule";
-import { NetworkState } from "../model/network/NetworkState";
-
-import type { SettlementContract } from "./SettlementContract";
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { NetworkState } from "../../model/network/NetworkState";
+import type { BlockProof } from "../../prover/block/BlockProver";
+import type { SettlementSmartContract } from "../contracts/SettlementSmartContract";
 
 export type SettlementStateRecord = {
-  sequencerKey: Field;
+  sequencerKey: PublicKey;
   lastSettlementL1Block: UInt32;
 
   stateRoot: Field;
   networkStateHash: Field;
   blockHashRoot: Field;
-
-  promisedMessagesHash: Field;
-  honoredMessagesHash: Field;
 };
 
 export type SettlementHookInputs = {
@@ -28,10 +24,10 @@ export type SettlementHookInputs = {
 };
 
 export abstract class ProvableSettlementHook<
-  Config
+  Config,
 > extends ProtocolModule<Config> {
   public abstract beforeSettlement(
-    smartContract: SettlementContract,
+    smartContract: SettlementSmartContract,
     inputs: SettlementHookInputs
-  ): void;
+  ): Promise<void>;
 }

package/src/settlement/modules/NetworkStateSettlementModule.ts

@@ -3,16 +3,17 @@ import { UInt64 } from "o1js";
 import {
   ProvableSettlementHook,
   SettlementHookInputs,
-} from "../ProvableSettlementHook";
-import { SettlementContract } from "../SettlementContract";
+} from "../modularity/ProvableSettlementHook";
+import { SettlementSmartContract } from "../contracts/SettlementSmartContract";
 
 type NetworkStateSettlementModuleConfig = {
   blocksPerL1Block: UInt64;
 };
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
 export class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
-  public beforeSettlement(
-    smartContract: SettlementContract,
+  public async beforeSettlement(
+    smartContract: SettlementSmartContract,
     {
       blockProof,
       fromNetworkState,
@@ -20,7 +21,7 @@ export class NetworkStateSettlementModule extends ProvableSettlementHook<Network
       contractState,
       currentL1Block,
     }: SettlementHookInputs
-  ): void {
+  ) {
     const { lastSettlementL1Block } = contractState;
 
     const blocksPerL1Block = this.config.blocksPerL1Block.toConstant();
@@ -37,3 +38,5 @@ export class NetworkStateSettlementModule extends ProvableSettlementHook<Network
     // TODO Check within bounds efficiently
   }
 }
+
+/* eslint-enable @typescript-eslint/no-unused-vars */

package/src/state/State.ts

@@ -1,5 +1,5 @@
 import { Mixin } from "ts-mixer";
-import { Bool, Field, Provable, type FlexibleProvablePure } from "o1js";
+import { Bool, Field, Provable, type FlexibleProvablePure, Struct } from "o1js";
 import { container } from "tsyringe";
 import { dummyValue } from "@proto-kit/common";
 
@@ -54,6 +54,11 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
     super();
   }
 
+  private stateType = class StateType extends Struct({
+    value: this.valueType,
+    isSome: Bool,
+  }) {};
+
   /**
    * Returns the state that is currently the current state tree
    * value: The value-fields, or if not state was found, dummy values
@@ -61,7 +66,7 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    * (Basically, whether the value-fields are dummy values or actual values
    * @private
    */
-  private getState(): { value: Value; isSome: Bool } {
+  private async getState(): Promise<{ value: Value; isSome: Bool }> {
     this.hasStateServiceOrFail();
     this.hasPathOrFail();
 
@@ -71,8 +76,10 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
       .resolve(RuntimeMethodExecutionContext)
       .current().result;
 
+    // TODO Use Stateservice for this
     // First try to find a match inside already created stateTransitions
-    const previousMutatingTransitions = stateTransitions.filter((transition) =>
+    let previousMutatingTransitions: StateTransition<any>[] = [];
+    previousMutatingTransitions = stateTransitions.filter((transition) =>
       transition.path.equals(path).and(transition.to.isSome).toBoolean()
     );
     const pmtLength = previousMutatingTransitions.length;
@@ -88,7 +95,7 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
     }
 
     // If the value is still undefined, look it up in the stateService
-    const fields = stateServiceProvider.stateService.get(path);
+    const fields = await stateServiceProvider.stateService.get(path);
     if (fields) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       value = valueType.fromFields(fields) as Value;
@@ -106,12 +113,13 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @returns Optional value of the current state
    */
-  private witnessFromState() {
+  private async witnessFromState() {
     // get the value from storage, or return a dummy value instead
-    const value = Provable.witness(this.valueType, () => this.getState().value);
-
-    // check if the value exists in the storage or not
-    const isSome = Provable.witness(Bool, () => this.getState().isSome);
+    // also check if the value exists in the storage or not
+    const { value, isSome } = await Provable.witnessAsync(
+      this.stateType,
+      async () => await this.getState()
+    );
 
     return Option.from(isSome, value, this.valueType);
   }
@@ -122,8 +130,8 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @returns Option representation of the current state.
    */
-  public get(): Option<Value> {
-    const option = this.witnessFromState();
+  public async get(): Promise<Option<Value>> {
+    const option = await this.witnessFromState();
 
     this.hasPathOrFail();
 
@@ -147,9 +155,9 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @param value - Value to be set as the current state
    */
-  public set(value: Value) {
+  public async set(value: Value) {
     // link the transition to the current state
-    const fromOption = this.witnessFromState();
+    const fromOption = await this.witnessFromState();
     const toOption = Option.fromValue(value, this.valueType);
 
     this.hasPathOrFail();

package/src/state/StateMap.ts

@@ -9,7 +9,6 @@ import { State, WithStateServiceProvider, WithPath } from "./State";
 /**
  * Map-like wrapper for state
  */
-// eslint-disable-next-line new-cap
 export class StateMap<KeyType, ValueType> extends Mixin(
   WithPath,
   WithStateServiceProvider
@@ -46,14 +45,14 @@ export class StateMap<KeyType, ValueType> extends Mixin(
    * @param key - Key to obtain the state for
    * @returns Value for the provided key.
    */
-  public get(key: KeyType): Option<ValueType> {
+  public async get(key: KeyType): Promise<Option<ValueType>> {
     const state = State.from(this.valueType);
     this.hasPathOrFail();
     this.hasStateServiceOrFail();
 
     state.path = this.getPath(key);
     state.stateServiceProvider = this.stateServiceProvider;
-    return state.get();
+    return await state.get();
   }
 
   /**
@@ -62,13 +61,13 @@ export class StateMap<KeyType, ValueType> extends Mixin(
    * @param key - Key to store the value under
    * @param value - Value to be stored under the given key
    */
-  public set(key: KeyType, value: ValueType): void {
+  public async set(key: KeyType, value: ValueType): Promise<void> {
     const state = State.from(this.valueType);
     this.hasPathOrFail();
     this.hasStateServiceOrFail();
 
     state.path = Path.fromKey(this.path, this.keyType, key);
     state.stateServiceProvider = this.stateServiceProvider;
-    state.set(value);
+    return await state.set(value);
   }
 }

package/src/state/StateService.ts

@@ -1,6 +1,6 @@
 import { Field } from "o1js";
 
-export interface StateService {
-  get: (key: Field) => Field[] | undefined;
-  set: (key: Field, value: Field[] | undefined) => void;
+export interface SimpleAsyncStateService {
+  get: (key: Field) => Promise<Field[] | undefined>;
+  set: (key: Field, value: Field[] | undefined) => Promise<void>;
 }

package/src/state/StateServiceProvider.ts

@@ -1,8 +1,8 @@
-import { inject, injectable } from "tsyringe";
-
-import { StateService } from "./StateService";
+import { injectable } from "tsyringe";
 import { log } from "@proto-kit/common";
 
+import { SimpleAsyncStateService } from "./StateService";
+
 const errors = {
   stateServiceNotSet: () =>
     new Error(
@@ -12,19 +12,18 @@ const errors = {
 
 @injectable()
 export class StateServiceProvider {
-  private readonly stateServiceStack: StateService[] = [];
+  private readonly stateServiceStack: SimpleAsyncStateService[] = [];
 
-  public get stateService(): StateService {
+  public get stateService(): SimpleAsyncStateService {
     if (this.stateServiceStack.length === 0) {
       throw errors.stateServiceNotSet();
     }
 
     // Assertion here is ok, because we check that the array is not empty above
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     return this.stateServiceStack.at(-1)!;
   }
 
-  public setCurrentStateService(service: StateService) {
+  public setCurrentStateService(service: SimpleAsyncStateService) {
     this.stateServiceStack.push(service);
   }