STProver v3

.github/workflows/pull-request-develop.yml

@@ -80,7 +80,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 22.9.0
+          node-version: 18
           cache: npm
 
       - name: "Install dependencies"

packages/common/src/index.ts

@@ -2,6 +2,7 @@ export * from "./config/ModuleContainer";
 export * from "./config/ConfigurableModule";
 export * from "./config/ChildContainerProvider";
 export * from "./config/ChildContainerCreatable";
+export * from "./config/injectAlias";
 export * from "./types";
 export * from "./zkProgrammable/ZkProgrammable";
 export * from "./zkProgrammable/ProvableMethodExecutionContext";
@@ -22,4 +23,3 @@ export * from "./compiling/AtomicCompileHelper";
 export * from "./compiling/CompileRegistry";
 export * from "./compiling/CompilableModule";
 export * from "./compiling/services/ChildVerificationKeyService";
-export * from "./config/injectAlias";

packages/common/src/trees/RollupMerkleTree.ts

@@ -200,7 +200,7 @@ export function createMerkleTree(height: number): AbstractMerkleTreeClass {
 
     public static dummy() {
       return new RollupMerkleWitness({
-        isLeft: Array<Bool>(height - 1).fill(Bool(false)),
+        isLeft: Array<Bool>(height - 1).fill(Bool(true)),
         path: Array<Field>(height - 1).fill(Field(0)),
       });
     }
@@ -222,6 +222,7 @@ export function createMerkleTree(height: number): AbstractMerkleTreeClass {
     public static WITNESS = RollupMerkleWitness;
 
     // private in interface
+    // TODO Cache this in some static variable so that we don't recompute it every time
     readonly zeroes: bigint[];
 
     readonly store: MerkleTreeStore;

packages/common/src/utils.ts

@@ -5,6 +5,7 @@ import {
   DynamicProof,
   Proof,
 } from "o1js";
+import _ from "lodash";
 
 import { TypedClass } from "./types";
 
@@ -72,6 +73,26 @@ export function reduceSequential<T, U>(
   );
 }
 
+export function yieldSequential<Source, State, Target>(
+  array: Source[],
+  callbackfn: (
+    previousValue: State,
+    currentValue: Source,
+    currentIndex: number,
+    array: Source[]
+  ) => Promise<[State, Target]>,
+  initialValue: State
+): Promise<[State, Target[]]> {
+  return reduceSequential<Source, [State, Target[]]>(
+    array,
+    async ([state, collectedTargets], curr, index, arr) => {
+      const [newState, addition] = await callbackfn(state, curr, index, arr);
+      return [newState, collectedTargets.concat(addition)];
+    },
+    [initialValue, []]
+  );
+}
+
 export function mapSequential<T, R>(
   array: T[],
   f: (element: T, index: number, array: T[]) => Promise<R>
@@ -198,3 +219,43 @@ export function safeParseJson<T>(json: string) {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return JSON.parse(json) as T;
 }
+
+export type Nullable<T> = {
+  [Key in keyof T]: T[Key] | undefined;
+};
+
+export function isFull<T>(t: Nullable<T>): t is T {
+  return Object.values(t).findIndex((v) => v === undefined) === -1;
+}
+
+// TODO Restructure utils into separate package and multiple files
+
+export function padArray<T>(
+  array: T[],
+  batchSize: number,
+  generator: (index: number) => T
+): T[] {
+  const slice = array.slice();
+  const dummies = range(0, batchSize - (array.length % batchSize)).map((i) =>
+    generator(i + array.length)
+  );
+  slice.push(...dummies);
+  return slice;
+}
+
+export function batch<T>(
+  arr: T[],
+  batchSize: number,
+  dummy: (index: number) => T
+): T[][] {
+  const padded = padArray(arr, batchSize, dummy);
+
+  const partitioned = _.groupBy(
+    padded.map((v, i) => [v, i] as const),
+    ([v, i]) => Math.floor(i / batchSize)
+  );
+
+  const numBatches = Math.ceil(arr.length / batchSize);
+
+  return range(0, numBatches).map((i) => partitioned[i].map((x) => x[0]));
+}

packages/common/src/zkProgrammable/provableMethod.ts

@@ -31,7 +31,9 @@ export function toProver(
     );
 
     if (zkProgram === undefined) {
-      throw new Error("Correct ZkProgram not found");
+      throw new Error(
+        `Correct ZkProgram not found (searching for method ${methodName})`
+      );
     }
 
     if (areProofsEnabled) {

packages/deployment/src/queue/BullQueue.ts

@@ -51,6 +51,7 @@ export class BullQueue
           await this.activePromise;
         }
         let resOutside: () => void = () => {};
+        // TODO Use Promise.withResolvers() for that
         const promise = new Promise<void>((res) => {
           resOutside = res;
         });

packages/library/src/hooks/TransactionFeeHook.ts

@@ -6,11 +6,12 @@ import {
 } from "@proto-kit/module";
 import { inject, injectable } from "tsyringe";
 import {
+  BeforeTransactionHookArguments,
   ProvableTransactionHook,
-  BlockProverExecutionData,
   PublicKeyOption,
 } from "@proto-kit/protocol";
 import { Field, Provable, PublicKey } from "o1js";
+import { noop } from "@proto-kit/common";
 
 import { UInt64 } from "../math/UInt64";
 import { Balance, TokenId } from "../runtime/Balances";
@@ -122,8 +123,8 @@ export class TransactionFeeHook extends ProvableTransactionHook<TransactionFeeHo
    *
    * @param executionData
    */
-  public async onTransaction(
-    executionData: BlockProverExecutionData
+  public async beforeTransaction(
+    executionData: BeforeTransactionHookArguments
   ): Promise<void> {
     const feeConfig = Provable.witness(MethodFeeConfigData, () =>
       this.feeAnalyzer.getFeeConfig(
@@ -154,4 +155,8 @@ export class TransactionFeeHook extends ProvableTransactionHook<TransactionFeeHo
       UInt64.Unsafe.fromField(fee.value)
     );
   }
+
+  public async afterTransaction(): Promise<void> {
+    noop();
+  }
 }

packages/module/src/method/runtimeMethod.ts

@@ -1,7 +1,6 @@
 import { Bool, Field, FlexibleProvablePure, Poseidon } from "o1js";
 import { container } from "tsyringe";
 import {
-  StateTransition,
   ProvableStateTransition,
   MethodPublicOutput,
   RuntimeMethodExecutionContext,
@@ -40,7 +39,7 @@ const errors = {
 };
 
 export function toStateTransitionsHash(
-  stateTransitions: StateTransition<any>[]
+  stateTransitions: { toProvable: () => ProvableStateTransition }[]
 ) {
   const stateTransitionsHashList = new StateTransitionReductionList(
     ProvableStateTransition

packages/persistance/prisma/migrations/20250129115920_st_prover/migration.sql

@@ -0,0 +1,21 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `blockStateTransitions` on the `BlockResult` table. All the data in the column will be lost.
+  - You are about to drop the column `protocolTransitions` on the `TransactionExecutionResult` table. All the data in the column will be lost.
+  - Added the required column `beforeBlockStateTransitions` to the `Block` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `fromStateRoot` to the `Block` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `afterBlockStateTransitions` to the `BlockResult` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "Block" ADD COLUMN     "beforeBlockStateTransitions" JSON NOT NULL,
+ADD COLUMN     "fromStateRoot" TEXT NOT NULL;
+
+-- AlterTable
+ALTER TABLE "BlockResult" DROP COLUMN "blockStateTransitions",
+ADD COLUMN     "afterBlockStateTransitions" JSON NOT NULL,
+ADD COLUMN     "witnessedRoots" TEXT[];
+
+-- AlterTable
+ALTER TABLE "TransactionExecutionResult" DROP COLUMN "protocolTransitions";

packages/persistance/prisma/schema.prisma

@@ -40,11 +40,11 @@ model Transaction {
 }
 
 model TransactionExecutionResult {
-  stateTransitions Json @db.Json
-  protocolTransitions Json @db.Json
-  status Boolean
-  statusMessage String?
-  events Json @db.Json
+  // TODO Make StateTransitionBatch and StateTransition Table
+  stateTransitions Json    @db.Json
+  status           Boolean
+  statusMessage    String?
+  events           Json    @db.Json
 
   tx     Transaction @relation(fields: [txHash], references: [hash])
   txHash String      @id
@@ -65,6 +65,9 @@ model Block {
   fromBlockHashRoot           String
   fromMessagesHash            String
   toMessagesHash              String
+  fromStateRoot               String
+
+  beforeBlockStateTransitions Json @db.Json
 
   parentHash String? @unique
   parent     Block?  @relation("Parent", fields: [parentHash], references: [hash])
@@ -91,11 +94,12 @@ model Batch {
 model BlockResult {
   blockHash String @id @unique
 
-  stateRoot             String
-  blockHashRoot         String
-  afterNetworkState     Json   @db.Json
-  blockStateTransitions Json   @db.Json
-  blockHashWitness      Json   @db.Json
+  stateRoot                  String
+  blockHashRoot              String
+  witnessedRoots             String[]
+  afterNetworkState          Json     @db.Json
+  afterBlockStateTransitions Json     @db.Json
+  blockHashWitness           Json     @db.Json
 
   block Block? @relation(fields: [blockHash], references: [hash])
 }

packages/persistance/src/services/prisma/PrismaBlockStorage.ts

@@ -1,16 +1,14 @@
 import {
-  distinctByString,
   HistoricalBlockStorage,
   TransactionExecutionResult,
   Block,
   BlockResult,
   BlockQueue,
   BlockStorage,
   BlockWithResult,
-  BlockWithPreviousResult,
   BlockWithMaybeResult,
 } from "@proto-kit/sequencer";
-import { filterNonNull, log } from "@proto-kit/common";
+import { log } from "@proto-kit/common";
 import {
   Prisma,
   TransactionExecutionResult as DBTransactionExecutionResult,
@@ -108,6 +106,8 @@ export class PrismaBlockStorage
     await prismaClient.block.create({
       data: {
         ...encodedBlock,
+        beforeBlockStateTransitions:
+          encodedBlock.beforeBlockStateTransitions as Prisma.InputJsonArray,
         beforeNetworkState:
           encodedBlock.beforeNetworkState as Prisma.InputJsonObject,
         duringNetworkState:
@@ -122,8 +122,6 @@ export class PrismaBlockStorage
                 txHash: tx.txHash,
 
                 stateTransitions: tx.stateTransitions as Prisma.InputJsonArray,
-                protocolTransitions:
-                  tx.protocolTransitions as Prisma.InputJsonArray,
                 events: tx.events as Prisma.InputJsonArray,
               };
             }),
@@ -143,8 +141,8 @@ export class PrismaBlockStorage
       data: {
         afterNetworkState: encoded.afterNetworkState as Prisma.InputJsonValue,
         blockHashWitness: encoded.blockHashWitness as Prisma.InputJsonValue,
-        blockStateTransitions:
-          encoded.blockStateTransitions as Prisma.InputJsonValue,
+        afterBlockStateTransitions:
+          encoded.afterBlockStateTransitions as Prisma.InputJsonValue,
 
         stateRoot: encoded.stateRoot,
         blockHash: encoded.blockHash,
@@ -198,7 +196,7 @@ export class PrismaBlockStorage
     return result;
   }
 
-  public async getNewBlocks(): Promise<BlockWithPreviousResult[]> {
+  public async getNewBlocks(): Promise<BlockWithResult[]> {
     const blocks = await this.connection.prismaClient.block.findMany({
       where: {
         batch: null,
@@ -209,24 +207,13 @@ export class PrismaBlockStorage
             tx: true,
           },
         },
+        result: true,
       },
       orderBy: {
         height: Prisma.SortOrder.asc,
       },
     });
 
-    const blockHashes = blocks
-      .flatMap((block) => [block.parentHash, block.hash])
-      .filter(filterNonNull)
-      .filter(distinctByString);
-    const result = await this.connection.prismaClient.blockResult.findMany({
-      where: {
-        blockHash: {
-          in: blockHashes,
-        },
-      },
-    });
-
     return blocks.map((block, index) => {
       const transactions = block.transactions.map<TransactionExecutionResult>(
         (txresult) => {
@@ -236,28 +223,17 @@ export class PrismaBlockStorage
       const decodedBlock = this.blockMapper.mapIn(block);
       decodedBlock.transactions = transactions;
 
-      const correspondingResult = result.find(
-        (candidate) => candidate.blockHash === block.hash
-      );
+      const { result } = block;
 
-      if (correspondingResult === undefined) {
+      if (result === null) {
         throw new Error(
           `No BlockResult has been set for block ${block.hash} yet`
         );
       }
 
-      const parentResult = result.find(
-        (candidate) => candidate.blockHash === block.parentHash
-      );
       return {
-        block: {
-          block: decodedBlock,
-          result: this.blockResultMapper.mapIn(correspondingResult),
-        },
-        lastBlockResult:
-          parentResult !== undefined
-            ? this.blockResultMapper.mapIn(parentResult)
-            : undefined,
+        block: decodedBlock,
+        result: this.blockResultMapper.mapIn(result),
       };
     });
   }