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

package/src/prover/block/accummulators/BlockHashMerkleTree.ts

@@ -0,0 +1,24 @@
+import { createMerkleTree } from "@proto-kit/common";
+import { Bool, Field, Poseidon, Struct } from "o1js";
+
+export class BlockHashMerkleTree extends createMerkleTree(40) {}
+export class BlockHashMerkleTreeWitness extends BlockHashMerkleTree.WITNESS {}
+
+export class BlockHashTreeEntry extends Struct({
+  block: Struct({
+    index: Field,
+    transactionListHash: Field,
+  }),
+  closed: Bool,
+  // TODO We could add startingEternalTransactionsHash here to offer
+  //  a more trivial connection to the sequence state
+}) {
+  public hash(): Field {
+    // Mirroring Block.hash()
+    const blockHash = Poseidon.hash([
+      this.block.index,
+      this.block.transactionListHash,
+    ]);
+    return Poseidon.hash([blockHash, ...this.closed.toFields()]);
+  }
+}

package/src/prover/block/accummulators/RuntimeVerificationKeyTree.ts

@@ -0,0 +1,24 @@
+import { createMerkleTree } from "@proto-kit/common";
+import { Field, Poseidon, Struct, VerificationKey } from "o1js";
+
+export const treeFeeHeight = 10;
+export class VKTree extends createMerkleTree(treeFeeHeight) {}
+export class VKTreeWitness extends VKTree.WITNESS {}
+
+export class RuntimeVerificationKeyAttestation extends Struct({
+  verificationKey: VerificationKey,
+  witness: VKTreeWitness,
+}) {}
+
+export class MethodVKConfigData extends Struct({
+  methodId: Field,
+  vkHash: Field,
+}) {
+  public hash() {
+    return Poseidon.hash(MethodVKConfigData.toFields(this));
+  }
+}
+
+export interface MinimalVKTreeService {
+  getRoot: () => bigint;
+}

package/src/prover/block/services/RuntimeVerificationKeyRootService.ts

@@ -0,0 +1,20 @@
+import { injectable, Lifecycle, scoped } from "tsyringe";
+
+import { MinimalVKTreeService } from "../accummulators/RuntimeVerificationKeyTree";
+
+@injectable()
+@scoped(Lifecycle.ContainerScoped)
+export class RuntimeVerificationKeyRootService implements MinimalVKTreeService {
+  private injectedRoot?: bigint;
+
+  public setRoot(root: bigint) {
+    this.injectedRoot = root;
+  }
+
+  public getRoot() {
+    if (this.injectedRoot === undefined) {
+      throw new Error("VKTree root not set");
+    }
+    return this.injectedRoot;
+  }
+}

package/src/prover/statetransition/StateTransitionProvable.ts

@@ -1,18 +1,24 @@
-import { Field, Proof, Struct } from "snarkyjs";
-import { ZkProgrammable } from "@proto-kit/common";
+import { Field, Proof, Struct } from "o1js";
+import { WithZkProgrammable, CompilableModule } from "@proto-kit/common";
 
-import { StateTransitionProvableBatch } from "../../model/StateTransitionProvableBatch";
-
-import { StateTransitionWitnessProviderReference } from "./StateTransitionWitnessProviderReference";
+import {
+  MerkleWitnessBatch,
+  StateTransitionProvableBatch,
+} from "../../model/StateTransitionProvableBatch";
+import { AppliedStateTransitionBatchState } from "../../model/AppliedStateTransitionBatch";
 
 export class StateTransitionProverPublicInput extends Struct({
-  stateTransitionsHash: Field,
-  stateRoot: Field,
+  batchesHash: Field,
+  currentBatchStateHash: Field,
+  root: Field,
+  witnessedRootsHash: Field,
 }) {}
 
 export class StateTransitionProverPublicOutput extends Struct({
-  stateTransitionsHash: Field,
-  stateRoot: Field,
+  batchesHash: Field,
+  currentBatchStateHash: Field,
+  root: Field,
+  witnessedRootsHash: Field,
 }) {}
 
 export type StateTransitionProof = Proof<
@@ -21,20 +27,21 @@ export type StateTransitionProof = Proof<
 >;
 
 export interface StateTransitionProvable
-  extends ZkProgrammable<
-    StateTransitionProverPublicInput,
-    StateTransitionProverPublicOutput
-  > {
-  witnessProviderReference: StateTransitionWitnessProviderReference;
-
-  runBatch: (
+  extends WithZkProgrammable<
+      StateTransitionProverPublicInput,
+      StateTransitionProverPublicOutput
+    >,
+    CompilableModule {
+  proveBatch: (
     publicInput: StateTransitionProverPublicInput,
-    batch: StateTransitionProvableBatch
-  ) => StateTransitionProverPublicOutput;
+    batch: StateTransitionProvableBatch,
+    witnesses: MerkleWitnessBatch,
+    currentAppliedBatch: AppliedStateTransitionBatchState
+  ) => Promise<StateTransitionProverPublicOutput>;
 
   merge: (
     publicInput: StateTransitionProverPublicInput,
     proof1: StateTransitionProof,
     proof2: StateTransitionProof
-  ) => StateTransitionProverPublicOutput;
+  ) => Promise<StateTransitionProverPublicOutput>;
 }