Model STs in Persistence

packages/deployment/docker/lightnet/docker-compose.yml

@@ -12,5 +12,5 @@ services:
       - 8080:8080
       - 8181:8181
 #     archive endpoints
-      - 5432:5432
+      - 5433:5432
       - 8282:8282

packages/indexer/src/tasks/IndexBlockTaskParameters.ts

@@ -2,7 +2,11 @@ import { BlockWithResult } from "@proto-kit/sequencer";
 import {
   BlockMapper,
   BlockResultMapper,
+  StateTransitionBatchArrayMapper,
+  StateTransitionMapper,
   TransactionExecutionResultMapper,
+  STBatchOutput,
+  STArrayOutput,
 } from "@proto-kit/persistance";
 import { injectable } from "tsyringe";
 
@@ -13,37 +17,90 @@ export class IndexBlockTaskParametersSerializer {
   public constructor(
     public blockMapper: BlockMapper,
     public blockResultMapper: BlockResultMapper,
-    public transactionResultMapper: TransactionExecutionResultMapper
+    public transactionResultMapper: TransactionExecutionResultMapper,
+    public stateTransitionBatchMapper: StateTransitionBatchArrayMapper,
+    public stateTransitionMapper: StateTransitionMapper
   ) {}
 
   public toJSON(parameters: IndexBlockTaskParameters): string {
     return JSON.stringify({
-      block: this.blockMapper.mapOut(parameters.block),
-      transactions: parameters.block.transactions.map((tx) =>
-        this.transactionResultMapper.mapOut(tx)
-      ),
-      result: this.blockResultMapper.mapOut(parameters.result),
+      block: {
+        ...this.blockMapper.mapOut(parameters.block),
+        beforeBlockStateTransitions:
+          parameters.block.beforeBlockStateTransitions.map((st) =>
+            this.stateTransitionMapper.mapOut(st)
+          ),
+      },
+      transactions: parameters.block.transactions.map((tx) => {
+        const txMap = this.transactionResultMapper.mapOut(tx);
+        const stBatches = this.stateTransitionBatchMapper.mapOut(
+          tx.stateTransitions
+        );
+        return {
+          ...txMap,
+          stateTransitionBatch: stBatches.map(([batch, sts]) => ({
+            applied: batch.applied,
+            stateTransitions: sts,
+          })),
+        };
+      }),
+      result: {
+        ...this.blockResultMapper.mapOut(parameters.result),
+        afterBlockStateTransitions:
+          parameters.result.afterBlockStateTransitions.map((st) =>
+            this.stateTransitionMapper.mapOut(st)
+          ),
+      },
     });
   }
 
   public fromJSON(json: string): IndexBlockTaskParameters {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const parsed = JSON.parse(json) as {
-      block: ReturnType<BlockMapper["mapOut"]>;
-      transactions: ReturnType<TransactionExecutionResultMapper["mapOut"]>[];
-      result: ReturnType<BlockResultMapper["mapOut"]>;
+      block: ReturnType<BlockMapper["mapOut"]> & {
+        beforeBlockStateTransitions: ReturnType<
+          StateTransitionMapper["mapOut"]
+        >[];
+      };
+      transactions: (ReturnType<TransactionExecutionResultMapper["mapOut"]> & {
+        stateTransitionBatch: (STBatchOutput & {
+          stateTransitions: STArrayOutput;
+        })[];
+      })[];
+      result: ReturnType<BlockResultMapper["mapOut"]> & {
+        afterBlockStateTransitions: ReturnType<
+          StateTransitionMapper["mapOut"]
+        >[];
+      };
     };
 
-    const transactions = parsed.transactions.map((tx) =>
-      this.transactionResultMapper.mapIn(tx)
-    );
+    const transactions = parsed.transactions.map((tx) => {
+      const txMapped = this.transactionResultMapper.mapIn(tx);
+      const stBatch = tx.stateTransitionBatch.map<
+        [STBatchOutput, STArrayOutput]
+      >((batch) => [{ applied: batch.applied }, batch.stateTransitions]);
+      return {
+        ...txMapped,
+        stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch),
+      };
+    });
 
     return {
       block: {
         ...this.blockMapper.mapIn(parsed.block),
+        beforeBlockStateTransitions:
+          parsed.block.beforeBlockStateTransitions.map((st) =>
+            this.stateTransitionMapper.mapIn(st)
+          ),
         transactions,
       },
-      result: this.blockResultMapper.mapIn(parsed.result),
+      result: {
+        ...this.blockResultMapper.mapIn(parsed.result),
+        afterBlockStateTransitions:
+          parsed.result.afterBlockStateTransitions.map((st) =>
+            this.stateTransitionMapper.mapIn(st)
+          ),
+      },
     };
   }
 }

packages/persistance/prisma/migrations/20250226134830_st_batches/migration.sql

@@ -0,0 +1,52 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `beforeBlockStateTransitions` on the `Block` table. All the data in the column will be lost.
+  - You are about to drop the column `afterBlockStateTransitions` on the `BlockResult` table. All the data in the column will be lost.
+  - You are about to drop the column `stateTransitions` on the `TransactionExecutionResult` table. All the data in the column will be lost.
+
+*/
+-- AlterTable
+ALTER TABLE "Block" DROP COLUMN "beforeBlockStateTransitions";
+
+-- AlterTable
+ALTER TABLE "BlockResult" DROP COLUMN "afterBlockStateTransitions";
+
+-- AlterTable
+ALTER TABLE "TransactionExecutionResult" DROP COLUMN "stateTransitions";
+
+-- CreateTable
+CREATE TABLE "StateTransition" (
+    "id" SERIAL NOT NULL,
+    "batchId" INTEGER NOT NULL,
+    "path" TEXT NOT NULL,
+    "from" TEXT[],
+    "fromIsSome" BOOLEAN NOT NULL,
+    "to" TEXT[],
+    "toIsSome" BOOLEAN NOT NULL,
+
+    CONSTRAINT "StateTransition_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "StateTransitionBatch" (
+    "id" SERIAL NOT NULL,
+    "txExecutionResultId" TEXT,
+    "blockId" TEXT,
+    "blockResultId" TEXT,
+    "applied" BOOLEAN NOT NULL,
+
+    CONSTRAINT "StateTransitionBatch_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "StateTransition" ADD CONSTRAINT "StateTransition_batchId_fkey" FOREIGN KEY ("batchId") REFERENCES "StateTransitionBatch"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "StateTransitionBatch" ADD CONSTRAINT "StateTransitionBatch_txExecutionResultId_fkey" FOREIGN KEY ("txExecutionResultId") REFERENCES "TransactionExecutionResult"("txHash") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "StateTransitionBatch" ADD CONSTRAINT "StateTransitionBatch_blockId_fkey" FOREIGN KEY ("blockId") REFERENCES "Block"("hash") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "StateTransitionBatch" ADD CONSTRAINT "StateTransitionBatch_blockResultId_fkey" FOREIGN KEY ("blockResultId") REFERENCES "BlockResult"("blockHash") ON DELETE SET NULL ON UPDATE CASCADE;

packages/persistance/prisma/schema.prisma

@@ -39,18 +39,42 @@ model Transaction {
   IncomingMessageBatchTransaction IncomingMessageBatchTransaction[]
 }
 
+model StateTransition {
+  id         Int      @id @default(autoincrement())
+  batchId    Int
+  path       String
+  from       String[]
+  fromIsSome Boolean
+  to         String[]
+  toIsSome   Boolean
+
+  batch StateTransitionBatch @relation(fields: [batchId], references: [id])
+}
+
+model StateTransitionBatch {
+  id                  Int     @id @default(autoincrement())
+  txExecutionResultId String?
+  blockId             String?
+  blockResultId       String?
+  applied             Boolean
+
+  transactionExecutionResult TransactionExecutionResult? @relation(fields: [txExecutionResultId], references: [txHash])
+  block                      Block?                      @relation(fields: [blockId], references: [hash])
+  blockResult                BlockResult?                @relation(fields: [blockResultId], references: [blockHash])
+  stateTransitions           StateTransition[]
+}
+
 model TransactionExecutionResult {
-  // TODO Make StateTransitionBatch and StateTransition Table
-  stateTransitions Json    @db.Json
-  status           Boolean
-  statusMessage    String?
-  events           Json    @db.Json
+  status        Boolean
+  statusMessage String?
+  events        Json    @db.Json
 
   tx     Transaction @relation(fields: [txHash], references: [hash])
   txHash String      @id
 
-  block     Block  @relation(fields: [blockHash], references: [hash])
-  blockHash String
+  block                Block                  @relation(fields: [blockHash], references: [hash])
+  blockHash            String
+  stateTransitionBatch StateTransitionBatch[]
 }
 
 model Block {
@@ -67,17 +91,16 @@ model Block {
   toMessagesHash              String
   fromStateRoot               String
 
-  beforeBlockStateTransitions Json @db.Json
-
   parentHash String? @unique
   parent     Block?  @relation("Parent", fields: [parentHash], references: [hash])
   successor  Block?  @relation("Parent")
 
   transactions TransactionExecutionResult[]
   result       BlockResult?
 
-  batch       Batch? @relation(fields: [batchHeight], references: [height])
-  batchHeight Int?
+  batch                Batch?                 @relation(fields: [batchHeight], references: [height])
+  batchHeight          Int?
+  stateTransitionBatch StateTransitionBatch[]
 }
 
 model Batch {
@@ -94,14 +117,14 @@ model Batch {
 model BlockResult {
   blockHash String @id @unique
 
-  stateRoot                  String
-  blockHashRoot              String
-  witnessedRoots             String[]
-  afterNetworkState          Json     @db.Json
-  afterBlockStateTransitions Json     @db.Json
-  blockHashWitness           Json     @db.Json
+  stateRoot         String
+  blockHashRoot     String
+  witnessedRoots    String[]
+  afterNetworkState Json     @db.Json
+  blockHashWitness  Json     @db.Json
 
-  block Block? @relation(fields: [blockHash], references: [hash])
+  block                Block?                 @relation(fields: [blockHash], references: [hash])
+  stateTransitionBatch StateTransitionBatch[]
 }
 
 model Settlement {

packages/persistance/src/PrismaDatabaseConnection.ts

@@ -90,6 +90,8 @@ export class PrismaDatabaseConnection
       "Settlement",
       "IncomingMessageBatch",
       "IncomingMessageBatchTransaction",
+      "StateTransition",
+      "StateTransitionBatch",
     ];
 
     await this.prismaClient.$transaction(