@proto-kit/protocol 0.1.1-develop.191 → 0.1.1-develop.2024

package/src/hooks/AccountStateHook.ts

@@ -0,0 +1,80 @@
+import { PublicKey, Struct, UInt64 } from "o1js";
+import { injectable } from "tsyringe";
+import { noop } from "@proto-kit/common";
+
+import { StateMap } from "../state/StateMap";
+import { state } from "../state/protocol/ProtocolState";
+import {
+  ProvableTransactionHook,
+  BeforeTransactionHookArguments,
+} from "../protocol/ProvableTransactionHook";
+import { assert } from "../state/assert/assert";
+
+export class AccountState extends Struct({
+  nonce: UInt64,
+}) {}
+
+export type AccountStateHookConfig = {
+  maximumNonceLookahead?: number;
+};
+
+@injectable()
+export class AccountStateHook extends ProvableTransactionHook<AccountStateHookConfig> {
+  @state() public accountState = StateMap.from<PublicKey, AccountState>(
+    PublicKey,
+    AccountState
+  );
+
+  public async beforeTransaction({
+    transaction: { transaction },
+  }: BeforeTransactionHookArguments) {
+    const sender = transaction.sender.value;
+
+    const aso = await this.accountState.get(sender);
+
+    const accountState = aso.orElse(new AccountState({ nonce: UInt64.zero }));
+
+    const currentNonce = accountState.nonce;
+
+    // Either the nonce matches or the tx is a message, in which case we don't care
+    assert(
+      currentNonce
+        .equals(transaction.nonce.value)
+        .or(transaction.sender.isSome.not()),
+      () =>
+        `Nonce not matching: tx sent ${transaction.nonce.value.toString()}, onchain value is ${currentNonce.toString()}`
+    );
+
+    // Optimized version of transaction.sender.isSome ? currentNonce.add(1) : Field(0)
+    // Bcs Bool(true).toField() == 1
+    // TODO Think about if we want to rangecheck this. If not, we should store it as Field
+    const newNonce = UInt64.Unsafe.fromField(
+      currentNonce.value.add(1).mul(transaction.sender.isSome.toField())
+    );
+
+    await this.accountState.set(sender, new AccountState({ nonce: newNonce }));
+  }
+
+  public async afterTransaction() {
+    noop();
+  }
+
+  // Under these conditions we want the tx removed from the mempool.
+  public async removeTransactionWhen({
+    transaction: { transaction },
+  }: BeforeTransactionHookArguments): Promise<boolean> {
+    const sender = transaction.sender.value;
+
+    const aso = await this.accountState.get(sender);
+
+    const accountState = aso.orElse(new AccountState({ nonce: UInt64.zero }));
+
+    const currentNonce = accountState.nonce;
+
+    const exceedsMaximumLookahead = transaction.nonce.value.greaterThan(
+      currentNonce.add(this.config.maximumNonceLookahead ?? 10)
+    );
+    const nonceIsInPast = transaction.nonce.value.lessThan(currentNonce);
+    return nonceIsInPast.or(exceedsMaximumLookahead).toBoolean();
+  }
+}

package/src/hooks/BlockHeightHook.ts

@@ -0,0 +1,17 @@
+import { NetworkState } from "../model/network/NetworkState";
+import { ProvableBlockHook } from "../protocol/ProvableBlockHook";
+
+export class BlockHeightHook extends ProvableBlockHook<Record<string, never>> {
+  public async afterBlock(networkState: NetworkState): Promise<NetworkState> {
+    return new NetworkState({
+      block: {
+        height: networkState.block.height.add(1),
+      },
+      previous: networkState.previous,
+    });
+  }
+
+  public async beforeBlock(networkState: NetworkState): Promise<NetworkState> {
+    return networkState;
+  }
+}

package/src/hooks/LastStateRootBlockHook.ts

@@ -0,0 +1,25 @@
+import {
+  AfterBlockHookArguments,
+  ProvableBlockHook,
+} from "../protocol/ProvableBlockHook";
+import { NetworkState } from "../model/network/NetworkState";
+
+export class LastStateRootBlockHook extends ProvableBlockHook<
+  Record<string, never>
+> {
+  public async afterBlock(
+    networkState: NetworkState,
+    { stateRoot }: AfterBlockHookArguments
+  ): Promise<NetworkState> {
+    return new NetworkState({
+      block: networkState.block,
+      previous: {
+        rootHash: stateRoot,
+      },
+    });
+  }
+
+  public async beforeBlock(networkState: NetworkState): Promise<NetworkState> {
+    return networkState;
+  }
+}

package/src/hooks/NoopBlockHook.ts

@@ -0,0 +1,24 @@
+import { NoConfig } from "@proto-kit/common";
+
+import {
+  AfterBlockHookArguments,
+  BeforeBlockHookArguments,
+  ProvableBlockHook,
+} from "../protocol/ProvableBlockHook";
+import { NetworkState } from "../model/network/NetworkState";
+
+export class NoopBlockHook extends ProvableBlockHook<NoConfig> {
+  public async afterBlock(
+    networkState: NetworkState,
+    state: AfterBlockHookArguments
+  ): Promise<NetworkState> {
+    return networkState;
+  }
+
+  public async beforeBlock(
+    networkState: NetworkState,
+    state: BeforeBlockHookArguments
+  ): Promise<NetworkState> {
+    return networkState;
+  }
+}

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 { SettlementContractType } from "../settlement/contracts/settlement/SettlementBase";
+
+@injectable()
+export class NoopSettlementHook extends ProvableSettlementHook<
+  Record<string, never>
+> {
+  public async beforeSettlement(
+    contract: SettlementContractType,
+    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,73 @@
-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/AuthorizedTransaction";
 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/accumulators/BlockHashList";
 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 "./prover/transaction/TransactionProver";
+export * from "./prover/transaction/TransactionProvable";
+export * from "./prover/utils";
 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/settlement/SettlementBase";
+export * from "./settlement/contracts/settlement/SettlementContract";
+export * from "./settlement/contracts/settlement/BridgingSettlementContract";
+export * from "./settlement/contracts/BridgingSettlementContractModule";
+export * from "./settlement/contracts/SettlementSmartContractModule";
+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 * from "./settlement/ContractArgsRegistry";
 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,89 +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)];
-  }
-
-  /**
-   * @returns Provable representation of the current option.
-   */
-  public toProvable() {
-    return new ProvableOption({
-      isSome: this.isSome,
-      value: this.treeValue,
-    });
+  public orElse(defaultValue: Value): Value {
+    return Provable.if<Value>(
+      this.isSome,
+      this.valueType,
+      this.value,
+      defaultValue
+    );
   }
 
-  public toJSON() {
-    const valueContent = this.valueType
-      .toFields(this.value)
-      .map((field) => field.toString())
-      .reduce((a, b) => `${a}, ${b}`);
-
-    return {
-      isSome: this.isSome.toBoolean(),
-
-      value: `[${valueContent}]`,
-    };
+  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>
   ) {}
 
@@ -73,8 +79,16 @@ export class StateTransition<Value> {
   public toJSON() {
     return {
       path: this.path.toString(),
-      from: this.from.toJSON(),
-      to: this.to.toJSON(),
+      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()
+    );
+  }
 }