@proto-kit/protocol 0.1.1-develop.211 → 0.1.1-develop.2137

package/src/settlement/contracts/settlement/SettlementContract.ts

@@ -0,0 +1,75 @@
+import {
+  State,
+  UInt32,
+  AccountUpdateForest,
+  state,
+  method,
+  PublicKey,
+  Field,
+  Signature,
+  DeployArgs,
+  Permissions,
+} from "o1js";
+import { O1PublicKeyOption } from "@proto-kit/common";
+
+import { NetworkState } from "../../../model/network/NetworkState";
+
+import {
+  DynamicBlockProof,
+  SettlementBase,
+  SettlementContractType,
+} from "./SettlementBase";
+
+export class SettlementContract
+  extends SettlementBase
+  implements SettlementContractType
+{
+  @state(Field) sequencerKey = State<Field>();
+
+  @state(UInt32) lastSettlementL1BlockHeight = State<UInt32>();
+
+  @state(Field) stateRoot = State<Field>();
+
+  @state(Field) networkStateHash = State<Field>();
+
+  @state(Field) blockHashRoot = State<Field>();
+
+  public async deployAndInitialize(
+    args: DeployArgs | undefined,
+    permissions: Permissions,
+    sequencer: PublicKey,
+    dispatchContract: O1PublicKeyOption
+  ): Promise<void> {
+    dispatchContract.assertNone(
+      "Non-bridging settlement contract doesn't require a dispatch contract"
+    );
+
+    await super.deploy(args);
+
+    this.self.account.permissions.set(permissions);
+
+    await this.initializeBase(sequencer);
+  }
+
+  @method async approveBase(forest: AccountUpdateForest) {
+    this.checkZeroBalanceChange(forest);
+  }
+
+  @method async settle(
+    blockProof: DynamicBlockProof,
+    signature: Signature,
+    publicKey: PublicKey,
+    inputNetworkState: NetworkState,
+    outputNetworkState: NetworkState,
+    newPromisedMessagesHash: Field
+  ): Promise<void> {
+    await super.settleBase(
+      blockProof,
+      signature,
+      publicKey,
+      inputNetworkState,
+      outputNetworkState,
+      newPromisedMessagesHash
+    );
+  }
+}

package/src/settlement/messages/Deposit.ts

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

package/src/settlement/messages/OutgoingMessage.ts

@@ -0,0 +1,17 @@
+import { Field, Struct } from "o1js";
+
+export class OutgoingMessageKeyStruct extends Struct({
+  index: Field,
+  tokenId: Field,
+}) {}
+
+export type OutgoingMessageEvent<T> = {
+  key: OutgoingMessageKeyStruct;
+  value: T;
+  messageType: Field;
+};
+
+export type OutgoingMessage<T> = {
+  value: T;
+  messageType: Field;
+};

package/src/settlement/messages/OutgoingMessageArgument.ts

@@ -0,0 +1,62 @@
+import {
+  Bool,
+  Field,
+  FlexibleProvablePure,
+  Provable,
+  Struct,
+  Unconstrained,
+} from "o1js";
+import {
+  LinkedMerkleTree,
+  LinkedMerkleTreeReadWitness,
+} from "@proto-kit/common";
+
+import { OutgoingMessage } from "./OutgoingMessage";
+
+// TODO Make that dynamic based on processors configured
+export const OUTGOING_MESSAGE_BATCH_SIZE = 1;
+
+export function createMessageStruct<T>(type: FlexibleProvablePure<T>) {
+  return class MessageStruct extends Struct({
+    value: type,
+    messageType: Field,
+  }) {} satisfies FlexibleProvablePure<OutgoingMessage<T>>;
+}
+
+export class OutgoingMessageArgument extends Struct({
+  witness: LinkedMerkleTreeReadWitness,
+  messageType: Field,
+  data: Unconstrained<Field[]>,
+}) {
+  public static dummy(): OutgoingMessageArgument {
+    return new OutgoingMessageArgument({
+      witness: LinkedMerkleTree.dummyReadWitness(),
+      messageType: Field(0),
+      data: Unconstrained.from([]),
+    });
+  }
+}
+
+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/modularity/OutgoingMessageProcessor.ts

@@ -0,0 +1,78 @@
+import {
+  AccountUpdate,
+  Bool,
+  Field,
+  FlexibleProvablePure,
+  Poseidon,
+  PublicKey,
+} from "o1js";
+import { implement, NoConfig, prefixToField } from "@proto-kit/common";
+
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+
+export function outgoingMessageProcessor() {
+  return implement("OutgoingMessageProcessor");
+}
+
+export type MessageProcessorArgs = {
+  bridgeContract: {
+    publicKey: PublicKey;
+    tokenId: Field;
+  };
+};
+
+export abstract class OutgoingMessageProcessor<
+  T,
+  Config = NoConfig,
+> extends ProtocolModule<Config> {
+  private status: Bool = Bool(false);
+
+  private statusMessage?: string = undefined;
+
+  public assertTrue(b: Bool, msg?: string) {
+    this.status = this.status.and(b);
+    if (this.statusMessage === undefined) {
+      this.statusMessage = msg;
+    }
+  }
+
+  processMessage(
+    message: T,
+    args: MessageProcessorArgs
+  ): {
+    accountUpdates: AccountUpdate[];
+    status: Bool;
+    statusMessage?: string;
+  } {
+    this.status = Bool(true);
+    this.statusMessage = undefined;
+
+    const accountUpdates = this.process(message, args);
+
+    return {
+      accountUpdates,
+      status: this.status,
+      statusMessage: this.statusMessage,
+    };
+  }
+
+  public getMessageType(): Field {
+    // TODO static salt/prefix
+    // This executes the bigint poseidon behind the scenes, therefore creates a constant
+    const messageType = Poseidon.hash([prefixToField(this.messageType)]);
+    if (!messageType.isConstant()) {
+      throw new Error(
+        "Underlying poseidon implementation has changed and doesn't create a constant anymore"
+      );
+    }
+    return messageType;
+  }
+
+  abstract type: FlexibleProvablePure<T> & { name: string };
+
+  abstract messageType: string;
+
+  abstract dummy(): T;
+
+  abstract process(message: T, args: MessageProcessorArgs): AccountUpdate[];
+}

package/src/settlement/modularity/ProvableSettlementHook.ts

@@ -0,0 +1,36 @@
+import { Field, PublicKey, UInt32 } from "o1js";
+import { InferProofBase } from "@proto-kit/common";
+
+import { ProtocolModule } from "../../protocol/ProtocolModule";
+import { NetworkState } from "../../model/network/NetworkState";
+import type { BlockProof } from "../../prover/block/BlockProvable";
+import type { SettlementContractType } from "../contracts/settlement/SettlementBase";
+
+export type InputBlockProof = InferProofBase<BlockProof>;
+
+export type SettlementStateRecord = {
+  sequencerKey: PublicKey;
+  lastSettlementL1BlockHeight: UInt32;
+
+  stateRoot: Field;
+  networkStateHash: Field;
+  blockHashRoot: Field;
+};
+
+export type SettlementHookInputs = {
+  blockProof: InputBlockProof;
+  fromNetworkState: NetworkState;
+  toNetworkState: NetworkState;
+  newPromisedMessagesHash: Field;
+  contractState: SettlementStateRecord;
+  currentL1BlockHeight: UInt32;
+};
+
+export abstract class ProvableSettlementHook<
+  Config,
+> extends ProtocolModule<Config> {
+  public abstract beforeSettlement(
+    smartContract: SettlementContractType,
+    inputs: SettlementHookInputs
+  ): Promise<void>;
+}

package/src/settlement/modularity/types.ts

@@ -0,0 +1,23 @@
+import { TypedClass } from "@proto-kit/common";
+import { SmartContract } from "o1js";
+
+import {
+  ContractModule,
+  SmartContractClassFromInterface,
+} from "../ContractModule";
+import type { SettlementModulesRecord } from "../SettlementContractModule";
+
+export type InferContractType<
+  Module extends TypedClass<ContractModule<any, any>>,
+> =
+  Module extends TypedClass<infer ConcreteModule>
+    ? ConcreteModule extends ContractModule<infer Contract, any>
+      ? Contract & SmartContract
+      : never
+    : never;
+
+export type GetContracts<SettlementModules extends SettlementModulesRecord> = {
+  [Key in keyof SettlementModules]: SmartContractClassFromInterface<
+    InferContractType<SettlementModules[Key]>
+  >;
+};

package/src/settlement/modules/NetworkStateSettlementModule.ts

@@ -0,0 +1,42 @@
+import { UInt64 } from "o1js";
+
+import {
+  ProvableSettlementHook,
+  SettlementHookInputs,
+} from "../modularity/ProvableSettlementHook";
+import { SettlementContractType } from "../contracts/settlement/SettlementBase";
+
+type NetworkStateSettlementModuleConfig = {
+  blocksPerL1Block: UInt64;
+};
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export class NetworkStateSettlementModule extends ProvableSettlementHook<NetworkStateSettlementModuleConfig> {
+  public async beforeSettlement(
+    smartContract: SettlementContractType,
+    {
+      blockProof,
+      fromNetworkState,
+      toNetworkState,
+      contractState,
+      currentL1BlockHeight,
+    }: SettlementHookInputs
+  ) {
+    const { lastSettlementL1BlockHeight } = contractState;
+
+    const blocksPerL1Block = this.config.blocksPerL1Block.toConstant();
+
+    const numL1Blocks = currentL1BlockHeight.sub(lastSettlementL1BlockHeight);
+    const expectedHeightDiff = numL1Blocks.toUInt64().mul(blocksPerL1Block);
+
+    const actualHeightDiff = toNetworkState.block.height.sub(
+      fromNetworkState.block.height
+    );
+
+    const acceptableDerivation = numL1Blocks.mul(1).div(10);
+
+    // 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 "snarkyjs";
+import { Bool, Field, Provable, type FlexibleProvablePure, Struct } from "o1js";
 import { container } from "tsyringe";
 import { dummyValue } from "@proto-kit/common";
 
@@ -9,6 +9,7 @@ import { StateTransition } from "../model/StateTransition";
 
 import { StateServiceProvider } from "./StateServiceProvider";
 import { RuntimeMethodExecutionContext } from "./context/RuntimeMethodExecutionContext";
+import { WitnessBlockContext } from "./WitnessBlockContext";
 
 export class WithPath {
   public path?: Field;
@@ -54,7 +55,19 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
     super();
   }
 
-  private getState(): { value: Value; isSome: Bool } {
+  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
+   * isSome: Whether the values where found in the state or not
+   * (Basically, whether the value-fields are dummy values or actual values
+   * @private
+   */
+  private async getState(): Promise<{ value: Value; isSome: Bool }> {
     this.hasStateServiceOrFail();
     this.hasPathOrFail();
 
@@ -64,9 +77,13 @@ 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) =>
-      transition.path.equals(path).and(transition.to.isSome).toBoolean()
+    let previousMutatingTransitions: StateTransition<any>[] = [];
+    previousMutatingTransitions = stateTransitions.filter(
+      (transition) =>
+        transition.path.toConstant().toBigInt() ===
+          path.toConstant().toBigInt() && transition.to.isSome.toBoolean()
     );
     const pmtLength = previousMutatingTransitions.length;
 
@@ -81,7 +98,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;
@@ -99,12 +116,13 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @returns Optional value of the current state
    */
-  private witnessState() {
+  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);
   }
@@ -115,16 +133,22 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
    *
    * @returns Option representation of the current state.
    */
-  public get(): Option<Value> {
-    const option = this.witnessState();
+  public async get(): Promise<Option<Value>> {
+    const option = await this.witnessFromState();
 
     this.hasPathOrFail();
 
-    const stateTransition = StateTransition.from(this.path, option);
+    const { isInWitnessBlock } = container.resolve(WitnessBlockContext);
 
-    container
-      .resolve(RuntimeMethodExecutionContext)
-      .addStateTransition(stateTransition);
+    // If we're inside a witness block, we only want to retrieve the state
+    // to use as a witness but not emit an ST
+    if (!isInWitnessBlock) {
+      const stateTransition = StateTransition.from(this.path, option);
+
+      container
+        .resolve(RuntimeMethodExecutionContext)
+        .addStateTransition(stateTransition);
+    }
 
     return option;
   }
@@ -140,10 +164,10 @@ 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.witnessState();
-    const toOption = Option.from(Bool(true), value, this.valueType);
+    const fromOption = await this.witnessFromState();
+    const toOption = Option.fromValue(value, this.valueType);
 
     this.hasPathOrFail();
 
@@ -153,6 +177,12 @@ export class State<Value> extends Mixin(WithPath, WithStateServiceProvider) {
       toOption
     );
 
+    const { isInWitnessBlock } = container.resolve(WitnessBlockContext);
+
+    if (isInWitnessBlock) {
+      throw new Error("Cannot set state inside of provable block.");
+    }
+
     container
       .resolve(RuntimeMethodExecutionContext)
       .addStateTransition(stateTransition);

package/src/state/StateMap.ts

@@ -1,4 +1,4 @@
-import type { Field, FlexibleProvablePure } from "snarkyjs";
+import type { Field, FlexibleProvablePure } from "o1js";
 import { Mixin } from "ts-mixer";
 
 import { Path } from "../model/Path";
@@ -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 "snarkyjs";
+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,37 +1,37 @@
-import { inject, injectable } from "tsyringe";
+import { injectable } from "tsyringe";
+import { log } from "@proto-kit/common";
 
-import { StateService } from "./StateService";
+import { SimpleAsyncStateService } from "./StateService";
 
 const errors = {
   stateServiceNotSet: () =>
     new Error(
-      `StateService has not been set yet. Be sure to either call your runtime or 
-      protocol function by creating them with an AppChain or by setting the 
-      stateService manually.`
+      "StateService has not been set yet. Be sure to either call your runtime or protocol function by creating them with an AppChain or by setting the stateService manually."
     ),
 };
 
 @injectable()
 export class StateServiceProvider {
-  private readonly defaultStateService?: StateService =
-    this.currentStateService;
+  private readonly stateServiceStack: SimpleAsyncStateService[] = [];
 
-  public constructor(
-    @inject("StateService") private currentStateService?: StateService
-  ) {}
-
-  public get stateService(): StateService {
-    if (this.currentStateService === undefined) {
+  public get stateService(): SimpleAsyncStateService {
+    if (this.stateServiceStack.length === 0) {
       throw errors.stateServiceNotSet();
     }
-    return this.currentStateService;
+
+    // Assertion here is ok, because we check that the array is not empty above
+    return this.stateServiceStack.at(-1)!;
   }
 
-  public setCurrentStateService(service: StateService) {
-    this.currentStateService = service;
+  public setCurrentStateService(service: SimpleAsyncStateService) {
+    this.stateServiceStack.push(service);
   }
 
-  public resetToDefault() {
-    this.currentStateService = this.defaultStateService;
+  public popCurrentStateService() {
+    if (this.stateServiceStack.length === 0) {
+      log.trace("Trying to pop from empty state-service stack");
+      return;
+    }
+    this.stateServiceStack.pop();
   }
 }

package/src/state/WitnessBlockContext.ts

@@ -0,0 +1,54 @@
+import { container, singleton } from "tsyringe";
+import { Provable } from "o1js";
+
+@singleton()
+export class WitnessBlockContext {
+  public witnessBlockDepth: number = 0;
+
+  public get isInWitnessBlock() {
+    return this.witnessBlockDepth > 0;
+  }
+}
+
+const asyncProxyWitnessFunction = <
+  Ret,
+  F extends (...args: any[]) => Promise<Ret>,
+>(
+  originalFuncDef: F
+) => {
+  return async (...args: Parameters<F>) => {
+    const context = container.resolve(WitnessBlockContext);
+    context.witnessBlockDepth += 1;
+    try {
+      return await originalFuncDef(...args);
+    } finally {
+      context.witnessBlockDepth -= 1;
+    }
+  };
+};
+
+const proxySyncWitnessFunction = <
+  Params extends any[],
+  Ret,
+  F extends (...args: Params) => Ret,
+>(
+  originalFuncDef: F
+) => {
+  return (...args: Params): Ret => {
+    const context = container.resolve(WitnessBlockContext);
+    context.witnessBlockDepth += 1;
+    try {
+      return originalFuncDef(...args);
+    } finally {
+      context.witnessBlockDepth -= 1;
+    }
+  };
+};
+
+Provable.witnessAsync = asyncProxyWitnessFunction(Provable.witnessAsync);
+
+Provable.witness = proxySyncWitnessFunction(Provable.witness);
+
+Provable.witnessFields = proxySyncWitnessFunction(Provable.witnessFields);
+
+Provable.asProver = proxySyncWitnessFunction(Provable.asProver);