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

package/src/model/StateTransitionProvableBatch.ts

@@ -1,32 +1,134 @@
-import { Provable, Struct } from "snarkyjs";
+import { Bool, Field, Provable, Struct } from "o1js";
+import { batch, LinkedMerkleTreeWitness } from "@proto-kit/common";
 
 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: Provable.Array(
-    ProvableStateTransition,
+    ProvableStateTransitionEntry,
     constants.stateTransitionProverBatchSize
   ),
 }) {
-  public static fromTransitions(
-    transitions: ProvableStateTransition[]
-  ): StateTransitionProvableBatch {
-    const array = transitions.slice();
+  public static fromBatches(
+    batches: {
+      stateTransitions: ProvableStateTransition[];
+      applied: Bool;
+      witnessRoot: Bool;
+    }[]
+  ): StateTransitionProvableBatch[] {
+    const flattened: ProvableStateTransitionEntry[] = [];
 
-    while (array.length < constants.stateTransitionProverBatchSize) {
-      array.push(ProvableStateTransition.dummy());
+    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),
+            };
+          }
+        );
+
+      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()
+    );
 
-  private constructor(object: { batch: ProvableStateTransition[] }) {
-    super(object);
+    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,13 +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));
+    return Poseidon.hash([
+      ...CurrentBlock.toFields(this.block),
+      ...PreviousBlock.toFields(this.previous),
+    ]);
+  }
+
+  public static empty() {
+    return new NetworkState({
+      block: {
+        height: UInt64.zero,
+      },
+      previous: {
+        rootHash: Field(RollupMerkleTree.EMPTY_ROOT),
+      },
+    });
   }
 }

package/src/model/transaction/AuthorizedTransaction.ts

@@ -0,0 +1,50 @@
+import { Bool, Field, Scalar, Signature, Struct, UInt64 } from "o1js";
+
+import { RuntimeTransaction } from "./RuntimeTransaction";
+
+export class AuthorizedTransaction extends Struct({
+  transaction: RuntimeTransaction,
+  signature: Signature,
+  isMessage: Bool,
+}) {
+  public static getSignatureData(args: {
+    methodId: Field;
+    nonce: UInt64;
+    argsHash: Field;
+  }): Field[] {
+    // No isMessage here - we don't sign that
+    return [args.methodId, ...args.nonce.value.toFields(), args.argsHash];
+  }
+
+  public static dummy(): AuthorizedTransaction {
+    return new AuthorizedTransaction({
+      transaction: RuntimeTransaction.dummyTransaction(),
+
+      signature: Signature.fromObject({
+        s: Scalar.from(0),
+        r: Field(0),
+      }),
+
+      isMessage: Bool(false),
+    });
+  }
+
+  public hash(): Field {
+    return this.transaction.hash();
+  }
+
+  public getSignatureData(): Field[] {
+    const { methodId, argsHash, nonce } = this.transaction;
+    return AuthorizedTransaction.getSignatureData({
+      nonce: nonce.value,
+      methodId,
+      argsHash,
+    });
+  }
+
+  public validateAuthorization(): Bool {
+    return this.signature
+      .verify(this.transaction.sender.value, this.getSignatureData())
+      .or(this.isMessage);
+  }
+}

package/src/model/transaction/RuntimeTransaction.ts

@@ -1,6 +1,7 @@
-import { Field, Poseidon, PublicKey, Struct, UInt64 } from "snarkyjs";
+import { Bool, Field, Poseidon, PublicKey, Struct, UInt64 } from "o1js";
+import { EMPTY_PUBLICKEY, EMPTY_PUBLICKEY_X } from "@proto-kit/common";
 
-import { ProtocolTransaction } from "./ProtocolTransaction";
+import { PublicKeyOption, UInt64Option } from "./ValueOption";
 
 /**
  * This struct is used to expose transaction information to the runtime method
@@ -9,30 +10,100 @@ import { ProtocolTransaction } from "./ProtocolTransaction";
  */
 export class RuntimeTransaction extends Struct({
   methodId: Field,
-  nonce: UInt64,
-  sender: PublicKey,
   argsHash: Field,
+  nonce: UInt64Option,
+  sender: PublicKeyOption,
 }) {
-  public static fromProtocolTransaction({
+  public static fromTransaction(input: {
+    methodId: Field;
+    argsHash: Field;
+    nonce: UInt64;
+    sender: PublicKey;
+  }) {
+    return new RuntimeTransaction({
+      methodId: input.methodId,
+      argsHash: input.argsHash,
+      nonce: UInt64Option.fromSome(input.nonce),
+      sender: PublicKeyOption.fromSome(input.sender),
+    });
+  }
+
+  public static fromMessage({
     methodId,
-    nonce,
-    sender,
     argsHash,
-  }: ProtocolTransaction): RuntimeTransaction {
+  }: {
+    methodId: Field;
+    argsHash: Field;
+  }) {
     return new RuntimeTransaction({
       methodId,
-      nonce,
-      sender,
       argsHash,
+      nonce: UInt64Option.none(UInt64.zero),
+      sender: PublicKeyOption.none(EMPTY_PUBLICKEY),
     });
   }
 
-  public hash(): Field {
-    return Poseidon.hash([
+  public static dummyTransaction(): RuntimeTransaction {
+    return new RuntimeTransaction({
+      methodId: Field(0),
+      nonce: new UInt64Option({
+        isSome: Bool(true),
+        value: UInt64.zero,
+      }),
+      sender: new PublicKeyOption({
+        isSome: Bool(true),
+        value: EMPTY_PUBLICKEY,
+      }),
+      argsHash: Field(0),
+    });
+  }
+
+  public assertTransactionType(isMessage: Bool) {
+    const isTransaction = isMessage.not();
+    // isSome has to be true when it is a transaction, otherwise false
+    this.nonce.isSome
+      .equals(isTransaction)
+      .assertTrue("Nonce is not right option isSome for type");
+    this.sender.isSome
+      .equals(isTransaction)
+      .assertTrue("Sender is not right option isSome for type");
+    this.sender.value.x
+      .equals(EMPTY_PUBLICKEY_X)
+      .equals(isMessage)
+      .assertTrue("Transaction sender is not set to dummy");
+  }
+
+  public isDummy(): Bool {
+    return this.methodId.equals(0);
+  }
+
+  public hashData(): Field[] {
+    return [
       this.methodId,
-      ...this.sender.toFields(),
-      ...this.nonce.toFields(),
+      ...this.sender.value.toFields(),
+      ...this.nonce.value.toFields(),
       this.argsHash,
-    ]);
+    ];
+  }
+
+  public static fromHashData(fields: Field[]) {
+    // sender is 2nd and the first element is x (2nd isOdd)
+    const isMessage = fields[1].equals(EMPTY_PUBLICKEY_X);
+    return new RuntimeTransaction({
+      methodId: fields[0],
+      sender: new PublicKeyOption({
+        isSome: isMessage.not(),
+        value: PublicKey.fromFields([fields[1], fields[2]]),
+      }),
+      nonce: new UInt64Option({
+        isSome: isMessage.not(),
+        value: UInt64.fromFields([fields[3]]),
+      }),
+      argsHash: fields[4],
+    });
+  }
+
+  public hash(): Field {
+    return Poseidon.hash(this.hashData());
   }
 }

package/src/model/transaction/ValueOption.ts

@@ -0,0 +1,28 @@
+import { Bool, ProvableExtended, PublicKey, Struct, UInt64 } from "o1js";
+
+function genericOptionFactory<Type>(valueType: ProvableExtended<Type>) {
+  return class Generic extends Struct({
+    isSome: Bool,
+    value: valueType,
+  }) {
+    public static fromSome(value: Type) {
+      return new Generic({
+        isSome: Bool(true),
+        value,
+      });
+    }
+
+    public static none(value: Type) {
+      return new Generic({
+        isSome: Bool(false),
+        value,
+      });
+    }
+  };
+}
+
+export class UInt64Option extends genericOptionFactory<UInt64>(UInt64) {}
+
+export class PublicKeyOption extends genericOptionFactory<PublicKey>(
+  PublicKey
+) {}