@proto-kit/protocol 0.1.1-develop.164 → 0.1.1-develop.1661

package/src/hooks/NoopSettlementHook.ts

@@ -0,0 +1,20 @@
+import { injectable } from "tsyringe";
+import { noop } from "@proto-kit/common";
+
+import {
+  ProvableSettlementHook,
+  SettlementHookInputs,
+} from "../settlement/modularity/ProvableSettlementHook";
+import { SettlementSmartContractBase } from "../settlement/contracts/SettlementSmartContract";
+
+@injectable()
+export class NoopSettlementHook extends ProvableSettlementHook<
+  Record<string, never>
+> {
+  public async beforeSettlement(
+    contract: SettlementSmartContractBase,
+    state: SettlementHookInputs
+  ) {
+    noop();
+  }
+}

package/src/hooks/NoopTransactionHook.ts

@@ -0,0 +1,13 @@
+import { noop } from "@proto-kit/common";
+
+import { ProvableTransactionHook } from "../protocol/ProvableTransactionHook";
+
+export class NoopTransactionHook extends ProvableTransactionHook {
+  public async beforeTransaction() {
+    noop();
+  }
+
+  public async afterTransaction() {
+    noop();
+  }
+}

package/src/index.ts

@@ -1,23 +1,65 @@
-export * from "./utils/ProvableHashList";
+export * from "./hooks/AccountStateHook";
+export * from "./hooks/BlockHeightHook";
+export * from "./hooks/LastStateRootBlockHook";
 export * from "./model/StateTransition";
 export * from "./model/StateTransitionProvableBatch";
 export * from "./model/Option";
 export * from "./model/Path";
 export * from "./model/network/NetworkState";
-export * from "./model/transaction/ProtocolTransaction";
+export * from "./model/transaction/SignedTransaction";
 export * from "./model/transaction/RuntimeTransaction";
-export * from "./utils/PrefixedProvableHashList.js";
+export * from "./model/transaction/ValueOption";
+export * from "./model/MethodPublicOutput";
+export * from "./model/RuntimeLike";
+export * from "./model/AppliedStateTransitionBatch";
+export * from "./utils/ProvableHashList";
+export * from "./utils/PrefixedProvableHashList";
+export * from "./utils/MinaPrefixedProvableHashList";
+export * from "./utils/ProvableReductionHashList";
 export * from "./utils/utils";
+export * from "./utils/FieldOptions";
+export * from "./prover/accumulators/StateTransitionReductionList";
+export * from "./prover/accumulators/AppliedBatchHashList";
+export * from "./prover/accumulators/WitnessedRootHashList";
+export * from "./prover/accumulators/TransactionHashList";
 export * from "./prover/block/BlockProver";
 export * from "./prover/block/BlockProvable";
+export * from "./prover/block/accummulators/RuntimeVerificationKeyTree";
+export * from "./prover/block/accummulators/BlockHashMerkleTree";
+export * from "./prover/block/services/RuntimeVerificationKeyRootService";
 export * from "./prover/statetransition/StateTransitionProver";
 export * from "./prover/statetransition/StateTransitionProvable";
-export * from "./prover/statetransition/StateTransitionWitnessProvider";
-export * from "./utils/merkletree/MerkleTreeStore";
-export * from "./utils/merkletree/InMemoryMerkleTreeStorage";
-export * from "./utils/merkletree/RollupMerkleTree";
-export * from "./model/MethodPublicOutput";
-export * from "./prover/statetransition/StateTransitionWitnessProviderReference";
 export * from "./protocol/Protocol";
 export * from "./protocol/ProtocolModule";
+export * from "./protocol/ProtocolEnvironment";
+export * from "./protocol/ProvableTransactionHook";
+export * from "./protocol/ProvableBlockHook";
+export * from "./state/context/TransitionMethodExecutionContext";
+export * from "./state/context/RuntimeMethodExecutionContext";
+export * from "./state/protocol/ProtocolState";
+export * from "./state/State";
+export * from "./state/StateMap";
+export * from "./state/StateService";
+export * from "./state/StateServiceProvider";
+export * from "./state/assert/assert";
+export * from "./settlement/contracts/authorizations/ContractAuthorization";
+export * from "./settlement/contracts/authorizations/UpdateMessagesHashAuth";
+export * from "./settlement/contracts/authorizations/TokenBridgeDeploymentAuth";
+export * from "./settlement/contracts/SettlementSmartContract";
+export * from "./settlement/contracts/SettlementContractProtocolModule";
+export * from "./settlement/contracts/DispatchSmartContract";
+export * from "./settlement/contracts/DispatchContractProtocolModule";
+export * from "./settlement/contracts/BridgeContract";
+export * from "./settlement/contracts/BridgeContractProtocolModule";
+export * from "./settlement/contracts/TokenBridgeTree";
+export * from "./settlement/SettlementContractModule";
+export * from "./settlement/ContractModule";
+export * from "./settlement/modularity/ProvableSettlementHook";
+export * from "./settlement/modularity/OutgoingMessageProcessor";
+export * from "./settlement/messages/OutgoingMessageArgument";
+export * from "./settlement/messages/OutgoingMessage";
+export * from "./settlement/modules/NetworkStateSettlementModule";
+export * from "./settlement/messages/Deposit";
 export { constants as ProtocolConstants } from "./Constants";
+export * from "./hashing/protokit-prefixes";
+export * from "./hashing/mina-prefixes";

package/src/model/AppliedStateTransitionBatch.ts

@@ -0,0 +1,16 @@
+import { Bool, Field, Poseidon, Provable, Struct } from "o1js";
+
+export class AppliedStateTransitionBatch extends Struct({
+  batchHash: Field,
+  applied: Bool,
+}) {}
+
+export class AppliedStateTransitionBatchState extends Struct({
+  batchHash: Field,
+  root: Field,
+}) {
+  public hashOrZero(): Field {
+    const hash = Poseidon.hash(AppliedStateTransitionBatchState.toFields(this));
+    return Provable.if(this.batchHash.equals(0), Field(0), hash);
+  }
+}

package/src/model/MethodPublicOutput.ts

@@ -1,4 +1,4 @@
-import { Bool, Field, Struct } from "snarkyjs";
+import { Bool, Field, Struct } from "o1js";
 
 /**
  * Public input used to link in-circuit execution with
@@ -9,4 +9,6 @@ export class MethodPublicOutput extends Struct({
   status: Bool,
   transactionHash: Field,
   networkStateHash: Field,
+  isMessage: Bool,
+  eventsHash: Field,
 }) {}

package/src/model/Option.ts

@@ -4,8 +4,9 @@ import {
   type FlexibleProvablePure,
   Poseidon,
   Provable,
+  ProvablePure,
   Struct,
-} from "snarkyjs";
+} from "o1js";
 
 export class ProvableOption extends Struct({
   isSome: Bool,
@@ -17,10 +18,70 @@ export class ProvableOption extends Struct({
   }
 }
 
+export abstract class OptionBase {
+  protected constructor(
+    public isSome: Bool,
+    public isForcedSome: Bool
+  ) {}
+
+  protected abstract encodeValueToFields(): Field[];
+
+  protected abstract clone(): OptionBase;
+
+  /**
+   * @returns Tree representation of the current value
+   */
+  public get treeValue() {
+    const treeValue = Poseidon.hash(this.encodeValueToFields());
+
+    return Provable.if(
+      this.isSome.and(this.isForcedSome.not()),
+      treeValue,
+      Field(0)
+    );
+  }
+
+  public forceSome() {
+    this.isForcedSome = Provable.if(this.isSome, Bool(false), Bool(true));
+    this.isSome = Bool(true);
+  }
+
+  /**
+   * Returns the `to`-value as decoded as a list of fields
+   * Not in circuit
+   */
+  public toFields(): Field[] {
+    if (this.isSome.toBoolean()) {
+      return this.encodeValueToFields();
+    }
+    return [Field(0)];
+  }
+
+  /**
+   * @returns Provable representation of the current option.
+   */
+  public toProvable() {
+    return new ProvableOption({
+      isSome: this.isSome,
+      value: this.treeValue,
+    });
+  }
+
+  public toJSON() {
+    const value = this.encodeValueToFields().map((field) => field.toString());
+
+    return {
+      isSome: this.isSome.toBoolean(),
+      isForcedSome: this.isForcedSome.toBoolean(),
+      value,
+    };
+  }
+}
+
 /**
  * Option facilitating in-circuit values that may or may not exist.
  */
-export class Option<Value> {
+export class Option<Value> extends OptionBase {
   /**
    * Creates a new Option from the provided parameters
    *
@@ -58,76 +119,54 @@ export class Option<Value> {
     return new Option(Bool(false), Field(0), Field);
   }
 
-  public static dummyValueFields<Value>(
-    valueType: FlexibleProvablePure<Value>
-  ): Field[] {
-    const length = valueType.sizeInFields();
-    return Array.from({ length }, () => Field(0));
-  }
-
-  /**
-   * Computes a dummy value for the given value type.
-   *
-   * @param valueType - Value type to generate the dummy value for
-   * @returns Dummy value for the given value type
-   */
-  public static dummyValue<Value>(
-    valueType: FlexibleProvablePure<Value>
-  ): Value {
-    const fields = Option.dummyValueFields(valueType);
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return valueType.fromFields(fields) as Value;
-  }
-
-  public isForcedSome = Bool(false);
-
   public constructor(
-    public isSome: Bool,
+    isSome: Bool,
     public value: Value,
-    public valueType: FlexibleProvablePure<Value>
-  ) {}
-
-  public clone() {
-    return new Option(this.isSome, this.value, this.valueType);
+    public valueType: FlexibleProvablePure<Value>,
+    isForcedSome = Bool(false)
+  ) {
+    super(isSome, isForcedSome);
   }
 
-  public forceSome() {
-    this.isForcedSome = Provable.if(this.isSome, Bool(false), Bool(true));
-    this.isSome = Bool(true);
+  public encodeValueToFields(): Field[] {
+    return this.valueType.toFields(this.value);
   }
 
-  /**
-   * @returns Tree representation of the current value
-   */
-  public get treeValue() {
-    const treeValue = Poseidon.hash(this.valueType.toFields(this.value));
-
-    return Provable.if(
-      this.isSome.and(this.isForcedSome.not()),
-      treeValue,
-      Field(0)
+  public clone(): Option<Value> {
+    return new Option(
+      this.isSome,
+      this.value,
+      this.valueType,
+      this.isForcedSome
     );
   }
 
   /**
-   * Returns the `to`-value as decoded as a list of fields
-   * Not in circuit
+   * @returns Returns the value of this option if it isSome,
+   * otherwise returns the given defaultValue
    */
-  public toFields(): Field[] {
-    if (this.isSome.toBoolean()) {
-      return this.valueType.toFields(this.value);
-    }
-    return [Field(0)];
+  public orElse(defaultValue: Value): Value {
+    return Provable.if<Value>(
+      this.isSome,
+      this.valueType,
+      this.value,
+      defaultValue
+    );
   }
 
-  /**
-   * @returns Provable representation of the current option.
-   */
-  public toProvable() {
-    return new ProvableOption({
-      isSome: this.isSome,
-      value: this.treeValue,
-    });
+  public toConstant() {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const valueConstant = (this.valueType as ProvablePure<Value>).fromFields(
+      this.valueType.toFields(this.value).map((field) => field.toConstant())
+    );
+    const boolConstant = (bool: Bool) =>
+      Bool.fromFields([bool.toField().toConstant()]);
+
+    return new Option(
+      boolConstant(this.isSome),
+      valueConstant,
+      this.valueType,
+      boolConstant(this.isForcedSome)
+    );
   }
 }

package/src/model/Path.ts

@@ -1,6 +1,5 @@
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @shopify/no-fully-static-classes */
-import { Field, type FlexibleProvablePure, Poseidon } from "snarkyjs";
+import { Field, type FlexibleProvablePure, Poseidon } from "o1js";
+import { hashWithPrefix } from "@proto-kit/common";
 
 import { stringToField } from "../utils/utils";
 
@@ -23,10 +22,15 @@ export class Path {
    *
    * @param className
    * @param propertyKey
+   * @param prefix
    * @returns Field representation of class name + property name
    */
-  public static fromProperty(className: string, propertyKey: string): Field {
-    return Poseidon.hash([
+  public static fromProperty(
+    className: string,
+    propertyKey: string,
+    prefix: string
+  ): Field {
+    return hashWithPrefix(prefix, [
       Path.toField(className),
       Path.toField(propertyKey),
       Field(0),

package/src/model/RuntimeLike.ts

@@ -0,0 +1,12 @@
+export type RuntimeMethodInvocationType = "INCOMING_MESSAGE" | "SIGNATURE";
+
+export type RuntimeMethodIdMapping = Record<
+  `${string}.${string}`,
+  { methodId: bigint; type: RuntimeMethodInvocationType }
+>;
+
+export interface RuntimeLike {
+  get methodIdResolver(): {
+    methodIdMap: () => RuntimeMethodIdMapping;
+  };
+}

package/src/model/StateTransition.ts

@@ -1,6 +1,6 @@
-import { Field, Struct } from "snarkyjs";
+import { Field, Struct } from "o1js";
 
-import { Option, ProvableOption } from "./Option.js";
+import { Option, ProvableOption } from "./Option";
 
 /**
  * Provable representation of a State Transition, used to
@@ -23,6 +23,12 @@ export class ProvableStateTransition extends Struct({
       to: Option.none().toProvable(),
     });
   }
+
+  public static isDummy(stateTransition: ProvableStateTransition) {
+    return stateTransition.path
+      .equals(0)
+      .and(stateTransition.from.isSome.not());
+  }
 }
 
 /**
@@ -44,7 +50,7 @@ export class StateTransition<Value> {
 
   public constructor(
     public path: Field,
-    public fromValue: Option<Field> | Option<Value>,
+    public fromValue: Option<Value>,
     public toValue: Option<Field> | Option<Value>
   ) {}
 
@@ -69,4 +75,20 @@ export class StateTransition<Value> {
       to: this.to.toProvable(),
     });
   }
+
+  public toJSON() {
+    return {
+      path: this.path.toString(),
+      from: this.fromValue.toJSON(),
+      to: this.toValue.toJSON(),
+    };
+  }
+
+  public toConstant(): StateTransition<Value> {
+    return new StateTransition<Value>(
+      this.path.toConstant(),
+      this.fromValue.toConstant(),
+      this.toValue.toConstant()
+    );
+  }
 }

package/src/model/StateTransitionProvableBatch.ts

@@ -1,31 +1,134 @@
-import { Circuit, Struct } from "snarkyjs";
+import { Bool, Field, Provable, Struct } from "o1js";
+import { batch, LinkedMerkleTreeWitness } from "@proto-kit/common";
 
-import { ProvableStateTransition } from "./StateTransition.js";
 import { constants } from "../Constants";
 
+import { ProvableStateTransition } from "./StateTransition.js";
+
+export class StateTransitionType {
+  public static readonly nothing = 2;
+
+  // The reason these are 0 and 1 is to efficiently check
+  // x in [inside, closing] in-circuit via the boolean trick
+  public static readonly closeAndApply = 1;
+
+  public static readonly closeAndThrowAway = 0;
+}
+
+/**
+ * STType is encoding both the type and whether it should be accumulated or not in one field
+ */
+export class ProvableStateTransitionType extends Struct({
+  type: Field,
+}) {
+  public static get nothing(): ProvableStateTransitionType {
+    return this.from(StateTransitionType.nothing);
+  }
+
+  public static get closeAndApply(): ProvableStateTransitionType {
+    return this.from(StateTransitionType.closeAndApply);
+  }
+
+  public static get closeAndThrowAway(): ProvableStateTransitionType {
+    return this.from(StateTransitionType.closeAndThrowAway);
+  }
+
+  private static from(constant: number) {
+    return new ProvableStateTransitionType({
+      type: Field(constant),
+    });
+  }
+
+  public isClosing() {
+    const { type } = this;
+    // check if base is 0 or 1
+    // 0^2 == 0 && 1^2 == 1
+    return type.mul(type).equals(type);
+  }
+
+  public isNothing() {
+    return this.type.equals(ProvableStateTransitionType.nothing.type);
+  }
+}
+
+export class MerkleWitnessBatch extends Struct({
+  witnesses: Provable.Array(
+    LinkedMerkleTreeWitness,
+    constants.stateTransitionProverBatchSize
+  ),
+}) {}
+
+export class ProvableStateTransitionEntry extends Struct({
+  stateTransition: ProvableStateTransition,
+  type: ProvableStateTransitionType,
+  witnessRoot: Bool,
+}) {
+  public static dummy(): ProvableStateTransitionEntry {
+    return {
+      stateTransition: ProvableStateTransition.dummy(),
+      type: ProvableStateTransitionType.nothing,
+      witnessRoot: Bool(false),
+    };
+  }
+}
+
 /**
  * A Batch of StateTransitions to be consumed by the StateTransitionProver
  * to prove multiple STs at once
+ *
+ * The batch is formed as an array fo ProvableSTEntries, which have a type and
+ * witnessesRoot flag attached to them.
  */
 export class StateTransitionProvableBatch extends Struct({
-  batch: Circuit.array(
-    ProvableStateTransition,
+  batch: Provable.Array(
+    ProvableStateTransitionEntry,
     constants.stateTransitionProverBatchSize
   ),
 }) {
-  private constructor(object: { batch: ProvableStateTransition[] }) {
-    super(object);
-  }
+  public static fromBatches(
+    batches: {
+      stateTransitions: ProvableStateTransition[];
+      applied: Bool;
+      witnessRoot: Bool;
+    }[]
+  ): StateTransitionProvableBatch[] {
+    const flattened: ProvableStateTransitionEntry[] = [];
 
-  public static fromTransitions(
-    transitions: ProvableStateTransition[]
-  ): StateTransitionProvableBatch {
-    const array = transitions.slice();
+    for (const stBatch of batches) {
+      const entries =
+        stBatch.stateTransitions.map<ProvableStateTransitionEntry>(
+          (stateTransition, j, sts) => {
+            return {
+              stateTransition,
+              type:
+                // eslint-disable-next-line no-nested-ternary
+                j === sts.length - 1
+                  ? stBatch.applied.toBoolean()
+                    ? ProvableStateTransitionType.closeAndApply
+                    : ProvableStateTransitionType.closeAndThrowAway
+                  : ProvableStateTransitionType.nothing,
+              witnessRoot: Bool(false),
+            };
+          }
+        );
 
-    while (array.length < constants.stateTransitionProverBatchSize) {
-      array.push(ProvableStateTransition.dummy());
+      flattened.push(...entries);
+
+      if (stBatch.witnessRoot.toBoolean() && flattened.length > 0) {
+        flattened.at(-1)!.witnessRoot = Bool(true);
+      }
     }
 
-    return new StateTransitionProvableBatch({ batch: array });
+    const values = batch(
+      flattened,
+      constants.stateTransitionProverBatchSize,
+      () => ProvableStateTransitionEntry.dummy()
+    );
+
+    return values.map((stBatch) => {
+      return new StateTransitionProvableBatch({
+        batch: stBatch,
+      });
+    });
   }
 }

package/src/model/Transaction.ts

@@ -6,13 +6,15 @@ import {
   Signature,
   Struct,
   UInt64,
-} from "snarkyjs";
+} from "o1js";
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function argsToHash(...args: FlexibleProvable<any>[]): Field {
   const fields = args.flatMap((argument) => argument.toFields(argument));
   return Poseidon.hash(fields);
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 class Transaction extends Struct({
   // must be checked inside @runtimeMethod
   methodId: Field,

package/src/model/network/NetworkState.ts

@@ -1,15 +1,33 @@
-import { Field, Poseidon, Struct, UInt64 } from "snarkyjs";
+import { Field, Poseidon, Struct, UInt64 } from "o1js";
+import { RollupMerkleTree } from "@proto-kit/common";
 
 export class CurrentBlock extends Struct({
   height: UInt64,
 }) {}
 
+export class PreviousBlock extends Struct({
+  rootHash: Field,
+}) {}
+
 export class NetworkState extends Struct({
   block: CurrentBlock,
+  previous: PreviousBlock,
 }) {
   public hash(): Field {
     return Poseidon.hash([
-      ...CurrentBlock.toFields(this.block)
-    ])
+      ...CurrentBlock.toFields(this.block),
+      ...PreviousBlock.toFields(this.previous),
+    ]);
+  }
+
+  public static empty() {
+    return new NetworkState({
+      block: {
+        height: UInt64.zero,
+      },
+      previous: {
+        rootHash: Field(RollupMerkleTree.EMPTY_ROOT),
+      },
+    });
   }
 }