From 4a7fd286dfb430e86ed5554c7c9550d879a54b9b Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Fri, 14 Feb 2025 13:56:43 +0000 Subject: [PATCH 01/39] Add in schema tables --- packages/persistance/prisma/schema.prisma | 33 ++++++++++++++++++----- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index 58c214477..51332ae4c 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -39,18 +39,37 @@ model Transaction { IncomingMessageBatchTransaction IncomingMessageBatchTransaction[] } +model StateTransition { + id Int @id @default(autoincrement()) + batchId Int + path String + from String? + to String? + + batch StateTransitionBatch @relation(fields: [batchId], references: [id]) +} + +model StateTransitionBatch { + id Int @id @default(autoincrement()) + txExecutionresultId String + stateTransitions String + StateTransition StateTransition[] + applied Boolean + + transctionExecutionResult TransactionExecutionResult @relation(fields: [txExecutionresultId], references: [txHash]) +} + 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 { From 5efdbd5f6aca7d574797a7c902f9144e4c694952 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 17 Feb 2025 09:26:40 +0000 Subject: [PATCH 02/39] Fix typo in table --- packages/persistance/prisma/schema.prisma | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index 51332ae4c..bb02b7e53 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -51,12 +51,12 @@ model StateTransition { model StateTransitionBatch { id Int @id @default(autoincrement()) - txExecutionresultId String + txExecutionResultId String stateTransitions String StateTransition StateTransition[] applied Boolean - transctionExecutionResult TransactionExecutionResult @relation(fields: [txExecutionresultId], references: [txHash]) + transctionExecutionResult TransactionExecutionResult @relation(fields: [txExecutionResultId], references: [txHash]) } model TransactionExecutionResult { From 37be1fdd773b022523aafaaff69e535b2739f0e7 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 17 Feb 2025 11:11:40 +0000 Subject: [PATCH 03/39] Fix typo in table --- packages/persistance/prisma/schema.prisma | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index bb02b7e53..6999b5288 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -50,13 +50,12 @@ model StateTransition { } model StateTransitionBatch { - id Int @id @default(autoincrement()) + id Int @id @default(autoincrement()) txExecutionResultId String - stateTransitions String - StateTransition StateTransition[] applied Boolean transctionExecutionResult TransactionExecutionResult @relation(fields: [txExecutionResultId], references: [txHash]) + StateTransition StateTransition[] } model TransactionExecutionResult { From 0582c53854a1f1aee0f2789e8a9d80402a7691c9 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 17 Feb 2025 11:16:43 +0000 Subject: [PATCH 04/39] Fix typo in table --- packages/persistance/prisma/schema.prisma | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index 6999b5288..74fd16c00 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -54,8 +54,8 @@ model StateTransitionBatch { txExecutionResultId String applied Boolean - transctionExecutionResult TransactionExecutionResult @relation(fields: [txExecutionResultId], references: [txHash]) - StateTransition StateTransition[] + transactionExecutionResult TransactionExecutionResult @relation(fields: [txExecutionResultId], references: [txHash]) + StateTransition StateTransition[] } model TransactionExecutionResult { From a36b23cf6e14282b8fd77aca46680d389bf43c58 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 18 Feb 2025 09:19:50 +0000 Subject: [PATCH 05/39] Update types to string array in db --- packages/persistance/prisma/schema.prisma | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index 74fd16c00..6d638a59d 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -40,11 +40,11 @@ model Transaction { } model StateTransition { - id Int @id @default(autoincrement()) + id Int @id @default(autoincrement()) batchId Int path String - from String? - to String? + from String[] + to String[] batch StateTransitionBatch @relation(fields: [batchId], references: [id]) } From d5be707ae29c40b57c6df056c1366c52984853f9 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 19 Feb 2025 12:35:49 +0000 Subject: [PATCH 06/39] Updated schema db to handle the before block --- packages/persistance/prisma/schema.prisma | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index 6d638a59d..e9828ac5a 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -51,10 +51,14 @@ model StateTransition { model StateTransitionBatch { id Int @id @default(autoincrement()) - txExecutionResultId String + txExecutionResultId String? + blockId String? + blockResultId String? applied Boolean - transactionExecutionResult TransactionExecutionResult @relation(fields: [txExecutionResultId], references: [txHash]) + transactionExecutionResult TransactionExecutionResult? @relation(fields: [txExecutionResultId], references: [txHash]) + block Block? @relation(fields: [blockId], references: [hash]) + blockResult BlockResult? @relation(fields: [blockResultId], references: [blockHash]) StateTransition StateTransition[] } @@ -94,8 +98,9 @@ model Block { 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 { @@ -119,7 +124,8 @@ model BlockResult { afterBlockStateTransitions 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 { From cdf1102e4753e7411fe169a53cc634c4986743ed Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 19 Feb 2025 13:07:47 +0000 Subject: [PATCH 07/39] Update mapOut for StBatch --- .../src/services/prisma/PrismaBlockStorage.ts | 37 +++++++++++++++++-- 1 file changed, 33 insertions(+), 4 deletions(-) diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 51ebaed62..cdf65ff0f 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -23,6 +23,10 @@ import { } from "./mappers/TransactionMapper"; import { BlockResultMapper } from "./mappers/BlockResultMapper"; import { BlockMapper } from "./mappers/BlockMapper"; +import { + StateTransitionBatchArrayMapper, + StateTransitionMapper, +} from "./mappers/StateTransitionMapper"; @injectable() export class PrismaBlockStorage @@ -33,7 +37,9 @@ export class PrismaBlockStorage private readonly transactionResultMapper: TransactionExecutionResultMapper, private readonly transactionMapper: TransactionMapper, private readonly blockResultMapper: BlockResultMapper, - private readonly blockMapper: BlockMapper + private readonly blockMapper: BlockMapper, + private readonly stateTransitionBatchMapper: StateTransitionBatchArrayMapper, + private readonly stateTransitionMapper: StateTransitionMapper ) {} private async getBlockByQuery( @@ -120,18 +126,41 @@ export class PrismaBlockStorage status: tx.status, statusMessage: tx.statusMessage, txHash: tx.txHash, - - stateTransitions: tx.stateTransitions as Prisma.InputJsonArray, events: tx.events as Prisma.InputJsonArray, }; }), skipDuplicates: true, }, }, - batchHeight: undefined, }, }); + + const stateTransitionBatches = block.transactions.flatMap((tx) => { + const batches = this.stateTransitionBatchMapper.mapOut( + tx.stateTransitions + ); + const resultMapper = this.transactionResultMapper.mapOut(tx)[0]; + return batches.map((batch, index) => ({ + ...batch, + txExecutionResultId: resultMapper.txHash, + stateTransitions: tx.stateTransitions[index].stateTransitions.map( + (sts) => this.stateTransitionMapper.mapOut(sts) + ), + })); + }); + + await prismaClient.stateTransitionBatch.createMany({ + data: stateTransitionBatches.map((batch) => ({ + ...batch, + stateTransitions: { + create: { + data: batch.stateTransitions, + }, + }, + })), + skipDuplicates: false, + }); } public async pushResult(result: BlockResult): Promise { From 06a4a41bb3ea994440dd4f61bc4edd7aaad69a84 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 19 Feb 2025 14:55:18 +0000 Subject: [PATCH 08/39] Start STMapper --- .../prisma/mappers/StateTransitionMapper.ts | 118 ++++++++++-------- 1 file changed, 66 insertions(+), 52 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index ed35da7b3..384fc766d 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -1,80 +1,94 @@ import { singleton } from "tsyringe"; import { StateTransitionBatch, + UntypedOption, UntypedStateTransition, } from "@proto-kit/sequencer"; -import { Prisma } from "@prisma/client"; +import { + StateTransitionBatch as DBStateTransitionBatch, + StateTransition as DBStateTransition, +} from "@prisma/client"; +import { Bool, Field } from "o1js"; import { ObjectMapper } from "../../../ObjectMapper"; @singleton() export class StateTransitionMapper - implements ObjectMapper -{ - public mapIn(input: Prisma.JsonObject): UntypedStateTransition { - // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - return UntypedStateTransition.fromJSON(input as any); - } - - public mapOut(input: UntypedStateTransition): Prisma.JsonObject { - return input.toJSON(); - } -} - -@singleton() -export class StateTransitionArrayMapper implements - ObjectMapper + ObjectMapper< + UntypedStateTransition, + Omit + > { - public constructor(private readonly stMapper: StateTransitionMapper) {} - - public mapIn(input: Prisma.JsonValue | undefined): UntypedStateTransition[] { - if (input === undefined) return []; - - if (Array.isArray(input)) { - return (input as Prisma.JsonArray).map((stJson) => - this.stMapper.mapIn(stJson as Prisma.JsonObject) - ); - } - return []; + public mapOut( + input: UntypedStateTransition + ): Omit { + return { + path: input.path.toString(), + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + from: input.from.isSome + ? input.from.value.map((x: Field) => x.toString()) + : [], + // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions + to: input.to.isSome ? input.to.value.map((x: Field) => x.toString()) : [], + }; } - public mapOut(input: UntypedStateTransition[]): Prisma.JsonValue { - return input.map((st) => this.stMapper.mapOut(st)) as Prisma.JsonArray; + public mapIn( + input: Omit + ): UntypedStateTransition { + return UntypedStateTransition.fromJSON({ + path: input.path, + from: { + isSome: input.from.length !== 0, + value: input.from, + isForcedSome: false, + }, + to: { + isSome: input.to.length !== 0, + value: input.to, + isForcedSome: false, + }, + }); } } @singleton() export class StateTransitionBatchArrayMapper - implements ObjectMapper + implements + ObjectMapper< + StateTransitionBatch[], + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >[] + > { public constructor( - private readonly stArrayMapper: StateTransitionArrayMapper + private readonly stateTransitionMapper: StateTransitionMapper ) {} - public mapOut(input: StateTransitionBatch[]): Prisma.JsonValue { - return input.map((st) => ({ - stateTransitions: this.stArrayMapper.mapOut( - st.stateTransitions - ) as Prisma.JsonArray, - applied: st.applied, + public mapOut( + input: StateTransitionBatch[] + ): Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >[] { + return input.map((stBatch) => ({ + applied: stBatch.applied, })); } - public mapIn(input: Prisma.JsonValue): StateTransitionBatch[] { - if (input === undefined) return []; - - if (Array.isArray(input)) { - return (input as Prisma.JsonArray).map((stJson) => { - const batchJsonObject = stJson as Prisma.JsonObject; - return { - stateTransitions: this.stArrayMapper.mapIn( - batchJsonObject.stateTransitions - ), - applied: batchJsonObject.applied as boolean, - }; - }); - } - return []; + public mapIn( + input: Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >[] + ): StateTransitionBatch[] { + return input.map(stBatch=> + ({ + applied: stBatch.applied, + stateTransitions: fhfhf, + }); } } From 69d6ba00cea4f6475c2297ca97d6d284d5ff103c Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 19 Feb 2025 15:43:59 +0000 Subject: [PATCH 09/39] Fix mapIn and mapOut --- .../src/services/prisma/PrismaBlockStorage.ts | 6 +-- .../prisma/mappers/StateTransitionMapper.ts | 53 ++++++++++++------- 2 files changed, 35 insertions(+), 24 deletions(-) diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index cdf65ff0f..7d46ef4c2 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -142,11 +142,9 @@ export class PrismaBlockStorage ); const resultMapper = this.transactionResultMapper.mapOut(tx)[0]; return batches.map((batch, index) => ({ - ...batch, + ...batch[0], txExecutionResultId: resultMapper.txHash, - stateTransitions: tx.stateTransitions[index].stateTransitions.map( - (sts) => this.stateTransitionMapper.mapOut(sts) - ), + stateTransitions: batch[1], })); }); diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index 384fc766d..4945f054d 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -58,10 +58,13 @@ export class StateTransitionBatchArrayMapper implements ObjectMapper< StateTransitionBatch[], - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >[] + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][] > { public constructor( @@ -70,25 +73,35 @@ export class StateTransitionBatchArrayMapper public mapOut( input: StateTransitionBatch[] - ): Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >[] { - return input.map((stBatch) => ({ - applied: stBatch.applied, - })); + ): [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][] { + return input.map((stBatch) => [ + { + applied: stBatch.applied, + }, + stBatch.stateTransitions.map((st) => + this.stateTransitionMapper.mapOut(st) + ), + ]); } public mapIn( - input: Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >[] + input: [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][] ): StateTransitionBatch[] { - return input.map(stBatch=> - ({ - applied: stBatch.applied, - stateTransitions: fhfhf, - }); + return input.map((x) => ({ + applied: x[0].applied, + stateTransitions: x[1].map((st) => this.stateTransitionMapper.mapIn(st)), + })); } } From aa5dd029e946a6989fc0c9abb206e7378b03b377 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 19 Feb 2025 15:55:22 +0000 Subject: [PATCH 10/39] Remove unused types --- .../src/services/prisma/mappers/StateTransitionMapper.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index 4945f054d..0c11b0378 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -1,14 +1,13 @@ import { singleton } from "tsyringe"; import { StateTransitionBatch, - UntypedOption, UntypedStateTransition, } from "@proto-kit/sequencer"; import { StateTransitionBatch as DBStateTransitionBatch, StateTransition as DBStateTransition, } from "@prisma/client"; -import { Bool, Field } from "o1js"; +import { Field } from "o1js"; import { ObjectMapper } from "../../../ObjectMapper"; From 4598d070ab1578ad3959a3982defc9cb9060608c Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Thu, 20 Feb 2025 09:02:10 +0000 Subject: [PATCH 11/39] Update schema to remove before and after STs details from block --- packages/persistance/prisma/schema.prisma | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index e9828ac5a..dae2eaaae 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -89,8 +89,6 @@ 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") @@ -117,12 +115,11 @@ 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]) StateTransitionBatch StateTransitionBatch[] From ebe7803646202a5fcb719828d88b2cb2cb8be545 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Thu, 20 Feb 2025 10:09:24 +0000 Subject: [PATCH 12/39] Fix TransactionMapper.ts --- .../prisma/mappers/TransactionMapper.ts | 56 +++++++++++++++---- 1 file changed, 45 insertions(+), 11 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts b/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts index 1e242dace..220d2346e 100644 --- a/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts @@ -6,13 +6,15 @@ import { import { Transaction as DBTransaction, TransactionExecutionResult as DBTransactionExecutionResult, + StateTransition as DBStateTransition, + StateTransitionBatch as DBStateTransitionBatch, } from "@prisma/client"; import { Bool } from "o1js"; import { ObjectMapper } from "../../../ObjectMapper"; -import { StateTransitionBatchArrayMapper } from "./StateTransitionMapper"; import { EventArrayMapper } from "./EventMapper"; +import { StateTransitionBatchArrayMapper } from "./StateTransitionMapper"; @singleton() @injectable() @@ -50,41 +52,73 @@ export class TransactionExecutionResultMapper implements ObjectMapper< TransactionExecutionResult, - [Omit, DBTransaction] + [ + Omit, + DBTransaction, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] > { public constructor( private readonly transactionMapper: TransactionMapper, - private readonly stBatchMapper: StateTransitionBatchArrayMapper, - private readonly eventArrayMapper: EventArrayMapper + private readonly eventArrayMapper: EventArrayMapper, + private readonly stBatchArrayMapper: StateTransitionBatchArrayMapper ) {} public mapIn( - input: [Omit, DBTransaction] + input: [ + Omit, + DBTransaction, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] ): TransactionExecutionResult { const executionResult = input[0]; + const stateTransitions = input[2]; return { tx: this.transactionMapper.mapIn(input[1]), status: Bool(executionResult.status), statusMessage: executionResult.statusMessage ?? undefined, - stateTransitions: this.stBatchMapper.mapIn( - executionResult.stateTransitions - ), events: this.eventArrayMapper.mapIn(executionResult.events), + stateTransitions: this.stBatchArrayMapper.mapIn(stateTransitions), }; } mapOut( input: TransactionExecutionResult - ): [Omit, DBTransaction] { + ): [ + Omit, + DBTransaction, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] { const tx = this.transactionMapper.mapOut(input.tx); const executionResult = { status: input.status.toBoolean(), statusMessage: input.statusMessage ?? null, - stateTransitions: this.stBatchMapper.mapOut(input.stateTransitions), events: this.eventArrayMapper.mapOut(input.events), txHash: tx.hash, }; - return [executionResult, tx]; + const stateTransitions = this.stBatchArrayMapper.mapOut( + input.stateTransitions + ); + + return [executionResult, tx, stateTransitions]; } } From c7748791fada2e700b751f18ef31a237953927d2 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Thu, 20 Feb 2025 13:04:56 +0000 Subject: [PATCH 13/39] BlockResultsMapper --- .../prisma/mappers/BlockResultMapper.ts | 83 ++++++++++++++----- 1 file changed, 63 insertions(+), 20 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts b/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts index fd65c6d02..6c0e54c1b 100644 --- a/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts @@ -1,44 +1,86 @@ import { singleton } from "tsyringe"; import { BlockResult } from "@proto-kit/sequencer"; -import { BlockResult as DBBlockResult } from "@prisma/client"; +import { + BlockResult as DBBlockResult, + StateTransition as DBStateTransition, + StateTransitionBatch as DBStateTransitionBatch, +} from "@prisma/client"; import { BlockHashMerkleTreeWitness, NetworkState } from "@proto-kit/protocol"; import { ObjectMapper } from "../../../ObjectMapper"; -import { StateTransitionArrayMapper } from "./StateTransitionMapper"; +import { StateTransitionBatchArrayMapper } from "./StateTransitionMapper"; @singleton() export class BlockResultMapper - implements ObjectMapper + implements + ObjectMapper< + BlockResult, + [ + DBBlockResult, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] + > { public constructor( - private readonly stArrayMapper: StateTransitionArrayMapper + private readonly stArrayMapper: StateTransitionBatchArrayMapper ) {} - public mapIn(input: DBBlockResult): BlockResult { + public mapIn( + input: [ + DBBlockResult, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] + ): BlockResult { + const dbBlockResult = input[0]; + const stBatch = input[1]; return { afterNetworkState: new NetworkState( // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - NetworkState.fromJSON(input.afterNetworkState as any) + NetworkState.fromJSON(dbBlockResult.afterNetworkState as any) ), - stateRoot: BigInt(input.stateRoot), - blockHashRoot: BigInt(input.blockHashRoot), + stateRoot: BigInt(dbBlockResult.stateRoot), + blockHashRoot: BigInt(dbBlockResult.blockHashRoot), blockHashWitness: new BlockHashMerkleTreeWitness( - // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - BlockHashMerkleTreeWitness.fromJSON(input.blockHashWitness as any) - ), - afterBlockStateTransitions: this.stArrayMapper.mapIn( - input.afterBlockStateTransitions + BlockHashMerkleTreeWitness.fromJSON( + // eslint-disable-next-line @typescript-eslint/no-unsafe-argument + dbBlockResult.blockHashWitness as any + ) ), - blockHash: BigInt(input.blockHash), + afterBlockStateTransitions: + this.stArrayMapper.mapIn(stBatch)[0].stateTransitions, + blockHash: BigInt(dbBlockResult.blockHash), - witnessedRoots: [BigInt(input.witnessedRoots[0])], + witnessedRoots: [BigInt(dbBlockResult.witnessedRoots[0])], }; } - public mapOut(input: BlockResult): DBBlockResult { - return { + public mapOut( + input: BlockResult + ): [ + DBBlockResult, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] { + const dbBlockResult = { stateRoot: input.stateRoot.toString(), blockHash: input.blockHash.toString(), blockHashRoot: input.blockHashRoot.toString(), @@ -46,12 +88,13 @@ export class BlockResultMapper blockHashWitness: BlockHashMerkleTreeWitness.toJSON( input.blockHashWitness ), - afterBlockStateTransitions: this.stArrayMapper.mapOut( - input.afterBlockStateTransitions - ), afterNetworkState: NetworkState.toJSON(input.afterNetworkState), witnessedRoots: [input.witnessedRoots[0].toString()], }; + const stBatches = this.stArrayMapper.mapOut([ + { stateTransitions: input.afterBlockStateTransitions, applied: true }, + ]); + return [dbBlockResult, stBatches]; } } From 41577018b3faff83a051f4678de2608c81ce1bc5 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Thu, 20 Feb 2025 13:24:45 +0000 Subject: [PATCH 14/39] BlockMapper --- .../services/prisma/mappers/BlockMapper.ts | 94 ++++++++++++++----- 1 file changed, 68 insertions(+), 26 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/BlockMapper.ts b/packages/persistance/src/services/prisma/mappers/BlockMapper.ts index bd5ee9b06..0ef07c15e 100644 --- a/packages/persistance/src/services/prisma/mappers/BlockMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/BlockMapper.ts @@ -1,55 +1,97 @@ import { singleton } from "tsyringe"; import { Block } from "@proto-kit/sequencer"; -import { Block as PrismaBlock } from "@prisma/client"; +import { + Block as PrismaBlock, + StateTransition as DBStateTransition, + StateTransitionBatch as DBStateTransitionBatch, +} from "@prisma/client"; import { NetworkState } from "@proto-kit/protocol"; import { Field } from "o1js"; import { ObjectMapper } from "../../../ObjectMapper"; -import { StateTransitionArrayMapper } from "./StateTransitionMapper"; +import { StateTransitionBatchArrayMapper } from "./StateTransitionMapper"; @singleton() -export class BlockMapper implements ObjectMapper { +export class BlockMapper + implements + ObjectMapper< + Block, + [ + PrismaBlock, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] + > +{ public constructor( - private readonly stArrayMapper: StateTransitionArrayMapper + private readonly stArrayMapper: StateTransitionBatchArrayMapper ) {} - public mapIn(input: PrismaBlock): Block { + public mapIn( + input: [ + PrismaBlock, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] + ): Block { + const block = input[0]; + const stBatch = input[1]; return { transactions: [], networkState: { before: new NetworkState( // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - NetworkState.fromJSON(input.beforeNetworkState as any) + NetworkState.fromJSON(block.beforeNetworkState as any) ), during: new NetworkState( // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - NetworkState.fromJSON(input.duringNetworkState as any) + NetworkState.fromJSON(block.duringNetworkState as any) ), }, - hash: Field(input.hash), - height: Field(input.height), - fromEternalTransactionsHash: Field(input.fromEternalTransactionsHash), - toEternalTransactionsHash: Field(input.toEternalTransactionsHash), - fromBlockHashRoot: Field(input.fromBlockHashRoot), - fromMessagesHash: Field(input.fromMessagesHash), - toMessagesHash: Field(input.toMessagesHash), - fromStateRoot: Field(input.fromStateRoot), + hash: Field(block.hash), + height: Field(block.height), + fromEternalTransactionsHash: Field(block.fromEternalTransactionsHash), + toEternalTransactionsHash: Field(block.toEternalTransactionsHash), + fromBlockHashRoot: Field(block.fromBlockHashRoot), + fromMessagesHash: Field(block.fromMessagesHash), + toMessagesHash: Field(block.toMessagesHash), + fromStateRoot: Field(block.fromStateRoot), - transactionsHash: Field(input.transactionsHash), + transactionsHash: Field(block.transactionsHash), previousBlockHash: - input.parentHash !== null ? Field(input.parentHash) : undefined, + block.parentHash !== null ? Field(block.parentHash) : undefined, - beforeBlockStateTransitions: this.stArrayMapper.mapIn( - input.beforeBlockStateTransitions - ), + beforeBlockStateTransitions: + this.stArrayMapper.mapIn(stBatch)[0].stateTransitions, }; } - public mapOut(input: Block): PrismaBlock { - return { + public mapOut( + input: Block + ): [ + PrismaBlock, + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ][], + ] { + const block = { height: Number(input.height.toBigInt()), beforeNetworkState: NetworkState.toJSON(input.networkState.before), duringNetworkState: NetworkState.toJSON(input.networkState.during), @@ -64,10 +106,10 @@ export class BlockMapper implements ObjectMapper { transactionsHash: input.transactionsHash.toString(), parentHash: input.previousBlockHash?.toString() ?? null, batchHeight: null, - - beforeBlockStateTransitions: this.stArrayMapper.mapOut( - input.beforeBlockStateTransitions - ), }; + const stBatches = this.stArrayMapper.mapOut([ + { stateTransitions: input.beforeBlockStateTransitions, applied: true }, + ]); + return [block, stBatches]; } } From 798807a8479a2720b9f321783b4c8d086460362f Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Thu, 20 Feb 2025 14:33:37 +0000 Subject: [PATCH 15/39] Update BlockMapper --- .../services/prisma/mappers/BlockMapper.ts | 81 +++++-------------- .../prisma/mappers/BlockResultMapper.ts | 67 ++++----------- 2 files changed, 32 insertions(+), 116 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/BlockMapper.ts b/packages/persistance/src/services/prisma/mappers/BlockMapper.ts index 0ef07c15e..f360207b4 100644 --- a/packages/persistance/src/services/prisma/mappers/BlockMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/BlockMapper.ts @@ -1,10 +1,6 @@ import { singleton } from "tsyringe"; import { Block } from "@proto-kit/sequencer"; -import { - Block as PrismaBlock, - StateTransition as DBStateTransition, - StateTransitionBatch as DBStateTransitionBatch, -} from "@prisma/client"; +import { Block as PrismaBlock } from "@prisma/client"; import { NetworkState } from "@proto-kit/protocol"; import { Field } from "o1js"; @@ -15,83 +11,46 @@ import { StateTransitionBatchArrayMapper } from "./StateTransitionMapper"; @singleton() export class BlockMapper implements - ObjectMapper< - Block, - [ - PrismaBlock, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] - > + ObjectMapper, PrismaBlock> { public constructor( private readonly stArrayMapper: StateTransitionBatchArrayMapper ) {} - public mapIn( - input: [ - PrismaBlock, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] - ): Block { - const block = input[0]; - const stBatch = input[1]; + public mapIn(input: PrismaBlock): Omit { return { transactions: [], networkState: { before: new NetworkState( // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - NetworkState.fromJSON(block.beforeNetworkState as any) + NetworkState.fromJSON(input.beforeNetworkState as any) ), during: new NetworkState( // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - NetworkState.fromJSON(block.duringNetworkState as any) + NetworkState.fromJSON(input.duringNetworkState as any) ), }, - hash: Field(block.hash), - height: Field(block.height), - fromEternalTransactionsHash: Field(block.fromEternalTransactionsHash), - toEternalTransactionsHash: Field(block.toEternalTransactionsHash), - fromBlockHashRoot: Field(block.fromBlockHashRoot), - fromMessagesHash: Field(block.fromMessagesHash), - toMessagesHash: Field(block.toMessagesHash), - fromStateRoot: Field(block.fromStateRoot), + hash: Field(input.hash), + height: Field(input.height), + fromEternalTransactionsHash: Field(input.fromEternalTransactionsHash), + toEternalTransactionsHash: Field(input.toEternalTransactionsHash), + fromBlockHashRoot: Field(input.fromBlockHashRoot), + fromMessagesHash: Field(input.fromMessagesHash), + toMessagesHash: Field(input.toMessagesHash), + fromStateRoot: Field(input.fromStateRoot), - transactionsHash: Field(block.transactionsHash), + transactionsHash: Field(input.transactionsHash), previousBlockHash: - block.parentHash !== null ? Field(block.parentHash) : undefined, - - beforeBlockStateTransitions: - this.stArrayMapper.mapIn(stBatch)[0].stateTransitions, + input.parentHash !== null ? Field(input.parentHash) : undefined, }; } public mapOut( - input: Block - ): [ - PrismaBlock, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] { - const block = { + input: Omit + ): PrismaBlock { + return { height: Number(input.height.toBigInt()), beforeNetworkState: NetworkState.toJSON(input.networkState.before), duringNetworkState: NetworkState.toJSON(input.networkState.during), @@ -107,9 +66,5 @@ export class BlockMapper parentHash: input.previousBlockHash?.toString() ?? null, batchHeight: null, }; - const stBatches = this.stArrayMapper.mapOut([ - { stateTransitions: input.beforeBlockStateTransitions, applied: true }, - ]); - return [block, stBatches]; } } diff --git a/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts b/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts index 6c0e54c1b..605cd1763 100644 --- a/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/BlockResultMapper.ts @@ -1,10 +1,6 @@ import { singleton } from "tsyringe"; import { BlockResult } from "@proto-kit/sequencer"; -import { - BlockResult as DBBlockResult, - StateTransition as DBStateTransition, - StateTransitionBatch as DBStateTransitionBatch, -} from "@prisma/client"; +import { BlockResult as DBBlockResult } from "@prisma/client"; import { BlockHashMerkleTreeWitness, NetworkState } from "@proto-kit/protocol"; import { ObjectMapper } from "../../../ObjectMapper"; @@ -15,17 +11,8 @@ import { StateTransitionBatchArrayMapper } from "./StateTransitionMapper"; export class BlockResultMapper implements ObjectMapper< - BlockResult, - [ - DBBlockResult, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] + Omit, + DBBlockResult > { public constructor( @@ -33,54 +20,32 @@ export class BlockResultMapper ) {} public mapIn( - input: [ - DBBlockResult, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] - ): BlockResult { - const dbBlockResult = input[0]; - const stBatch = input[1]; + input: DBBlockResult + ): Omit { return { afterNetworkState: new NetworkState( // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - NetworkState.fromJSON(dbBlockResult.afterNetworkState as any) + NetworkState.fromJSON(input.afterNetworkState as any) ), - stateRoot: BigInt(dbBlockResult.stateRoot), - blockHashRoot: BigInt(dbBlockResult.blockHashRoot), + stateRoot: BigInt(input.stateRoot), + blockHashRoot: BigInt(input.blockHashRoot), blockHashWitness: new BlockHashMerkleTreeWitness( BlockHashMerkleTreeWitness.fromJSON( // eslint-disable-next-line @typescript-eslint/no-unsafe-argument - dbBlockResult.blockHashWitness as any + input.blockHashWitness as any ) ), - afterBlockStateTransitions: - this.stArrayMapper.mapIn(stBatch)[0].stateTransitions, - blockHash: BigInt(dbBlockResult.blockHash), + blockHash: BigInt(input.blockHash), - witnessedRoots: [BigInt(dbBlockResult.witnessedRoots[0])], + witnessedRoots: [BigInt(input.witnessedRoots[0])], }; } public mapOut( - input: BlockResult - ): [ - DBBlockResult, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] { - const dbBlockResult = { + input: Omit + ): DBBlockResult { + return { stateRoot: input.stateRoot.toString(), blockHash: input.blockHash.toString(), blockHashRoot: input.blockHashRoot.toString(), @@ -92,9 +57,5 @@ export class BlockResultMapper witnessedRoots: [input.witnessedRoots[0].toString()], }; - const stBatches = this.stArrayMapper.mapOut([ - { stateTransitions: input.afterBlockStateTransitions, applied: true }, - ]); - return [dbBlockResult, stBatches]; } } From f641c619f65de5139c3345146e2f368ab5cfb49f Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Thu, 20 Feb 2025 20:10:28 +0000 Subject: [PATCH 16/39] Update TransactionMapper --- .../prisma/mappers/TransactionMapper.ts | 51 +++---------------- 1 file changed, 7 insertions(+), 44 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts b/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts index 220d2346e..30d67b308 100644 --- a/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts @@ -6,8 +6,6 @@ import { import { Transaction as DBTransaction, TransactionExecutionResult as DBTransactionExecutionResult, - StateTransition as DBStateTransition, - StateTransitionBatch as DBStateTransitionBatch, } from "@prisma/client"; import { Bool } from "o1js"; @@ -51,18 +49,8 @@ export class TransactionMapper export class TransactionExecutionResultMapper implements ObjectMapper< - TransactionExecutionResult, - [ - Omit, - DBTransaction, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] + Omit, + [Omit, DBTransaction] > { public constructor( @@ -72,42 +60,20 @@ export class TransactionExecutionResultMapper ) {} public mapIn( - input: [ - Omit, - DBTransaction, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] - ): TransactionExecutionResult { + input: [Omit, DBTransaction] + ): Omit { const executionResult = input[0]; - const stateTransitions = input[2]; return { tx: this.transactionMapper.mapIn(input[1]), status: Bool(executionResult.status), statusMessage: executionResult.statusMessage ?? undefined, events: this.eventArrayMapper.mapIn(executionResult.events), - stateTransitions: this.stBatchArrayMapper.mapIn(stateTransitions), }; } mapOut( - input: TransactionExecutionResult - ): [ - Omit, - DBTransaction, - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][], - ] { + input: Omit + ): [Omit, DBTransaction] { const tx = this.transactionMapper.mapOut(input.tx); const executionResult = { status: input.status.toBoolean(), @@ -115,10 +81,7 @@ export class TransactionExecutionResultMapper events: this.eventArrayMapper.mapOut(input.events), txHash: tx.hash, }; - const stateTransitions = this.stBatchArrayMapper.mapOut( - input.stateTransitions - ); - return [executionResult, tx, stateTransitions]; + return [executionResult, tx]; } } From 8474f7e1f538610fff2f9e3b3c385c53ab6f7a5f Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Thu, 20 Feb 2025 20:59:58 +0000 Subject: [PATCH 17/39] Fix PrismaBlockStorage --- .../src/services/prisma/PrismaBlockStorage.ts | 128 ++++++++++++++++-- 1 file changed, 116 insertions(+), 12 deletions(-) diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 7d46ef4c2..52d3a1666 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -12,6 +12,8 @@ import { log } from "@proto-kit/common"; import { Prisma, TransactionExecutionResult as DBTransactionExecutionResult, + StateTransition as DBStateTransition, + StateTransitionBatch as DBStateTransitionBatch, } from "@prisma/client"; import { inject, injectable } from "tsyringe"; @@ -51,25 +53,73 @@ export class PrismaBlockStorage transactions: { include: { tx: true, + StateTransitionBatch: { + include: { + StateTransition: true, + }, + }, + }, + }, + StateTransitionBatch: { + include: { + StateTransition: true, + }, + }, + result: { + include: { + StateTransitionBatch: { + include: { + StateTransition: true, + }, + }, }, }, - result: true, }, }); if (dbResult === null) { return undefined; } const transactions = dbResult.transactions.map( - (txresult) => this.transactionResultMapper.mapIn([txresult, txresult.tx]) + (txresult) => { + const txExecResult = this.transactionResultMapper.mapIn([ + txresult, + txresult.tx, + ]); + const stBatch = txresult.StateTransitionBatch.map< + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ] + >((batch) => [{ applied: batch.applied }, batch.StateTransition]); + return { + ...txExecResult, + stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch), + }; + } ); return { block: { ...this.blockMapper.mapIn(dbResult), + beforeBlockStateTransitions: + // Each block should just have one batch of STs associated with it + dbResult.StateTransitionBatch[0].StateTransition.map((st) => + this.stateTransitionMapper.mapIn(st) + ), transactions, }, result: dbResult.result - ? this.blockResultMapper.mapIn(dbResult.result) + ? { + ...this.blockResultMapper.mapIn(dbResult.result), + afterBlockStateTransitions: + // Each block should just have one batch of STs assoicated with it + dbResult.StateTransitionBatch[0].StateTransition.map((st) => + this.stateTransitionMapper.mapIn(st) + ), + } : undefined, }; } @@ -112,8 +162,6 @@ export class PrismaBlockStorage await prismaClient.block.create({ data: { ...encodedBlock, - beforeBlockStateTransitions: - encodedBlock.beforeBlockStateTransitions as Prisma.InputJsonArray, beforeNetworkState: encodedBlock.beforeNetworkState as Prisma.InputJsonObject, duringNetworkState: @@ -163,14 +211,24 @@ export class PrismaBlockStorage public async pushResult(result: BlockResult): Promise { const encoded = this.blockResultMapper.mapOut(result); + const batches = this.stateTransitionBatchMapper.mapOut([ + { stateTransitions: result.afterBlockStateTransitions, applied: true }, + ]); await this.connection.prismaClient.blockResult.create({ data: { afterNetworkState: encoded.afterNetworkState as Prisma.InputJsonValue, blockHashWitness: encoded.blockHashWitness as Prisma.InputJsonValue, - afterBlockStateTransitions: - encoded.afterBlockStateTransitions as Prisma.InputJsonValue, - + StateTransitionBatch: { + create: batches.map(([stBatch, sts]) => { + return { + ...stBatch, + stateTransitions: { + create: sts, + }, + }; + }), + }, stateRoot: encoded.stateRoot, blockHash: encoded.blockHash, blockHashRoot: encoded.blockHashRoot, @@ -233,9 +291,27 @@ export class PrismaBlockStorage transactions: { include: { tx: true, + StateTransitionBatch: { + include: { + StateTransition: true, + }, + }, + }, + }, + StateTransitionBatch: { + include: { + StateTransition: true, + }, + }, + result: { + include: { + StateTransitionBatch: { + include: { + StateTransition: true, + }, + }, }, }, - result: true, }, orderBy: { height: Prisma.SortOrder.asc, @@ -245,7 +321,23 @@ export class PrismaBlockStorage return blocks.map((block, index) => { const transactions = block.transactions.map( (txresult) => { - return this.transactionResultMapper.mapIn([txresult, txresult.tx]); + const txExecResult = this.transactionResultMapper.mapIn([ + txresult, + txresult.tx, + ]); + const stBatch = txresult.StateTransitionBatch.map< + [ + Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ] + >((batch) => [{ applied: batch.applied }, batch.StateTransition]); + return { + ...txExecResult, + stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch), + }; } ); const decodedBlock = this.blockMapper.mapIn(block); @@ -260,8 +352,20 @@ export class PrismaBlockStorage } return { - block: decodedBlock, - result: this.blockResultMapper.mapIn(result), + block: { + ...decodedBlock, + beforeBlockStateTransitions: + block.StateTransitionBatch[0].StateTransition.map((st) => + this.stateTransitionMapper.mapIn(st) + ), + }, + result: { + ...this.blockResultMapper.mapIn(result), + afterBlockStateTransitions: + result.StateTransitionBatch[0].StateTransition.map((st) => + this.stateTransitionMapper.mapIn(st) + ), + }, }; }); } From 4c139c0523dd053d4d7b1d4e802c445a617d737a Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 13:33:06 +0000 Subject: [PATCH 18/39] Fix BlockFetching.ts --- .../processor/src/indexer/BlockFetching.ts | 78 +++++++++++++++++-- 1 file changed, 70 insertions(+), 8 deletions(-) diff --git a/packages/processor/src/indexer/BlockFetching.ts b/packages/processor/src/indexer/BlockFetching.ts index 722f691d3..84a5772fd 100644 --- a/packages/processor/src/indexer/BlockFetching.ts +++ b/packages/processor/src/indexer/BlockFetching.ts @@ -4,11 +4,15 @@ import { BlockResult as PrismaBlockResult, Transaction as PrismaTransaction, TransactionExecutionResult as PrismaTransactionExecutionResult, + StateTransition as PrismaStateTransition, + StateTransitionBatch as PrismaStateTransitionBatch, } from "@prisma/client"; import { BlockMapper, BlockResultMapper, TransactionExecutionResultMapper, + StateTransitionMapper, + StateTransitionBatchArrayMapper, } from "@proto-kit/persistance"; import { log } from "@proto-kit/common"; import { injectable } from "tsyringe"; @@ -23,10 +27,16 @@ export interface BlockFetchingConfig { export interface BlockResponse { data: { findFirstBlock: PrismaBlock & { - result: PrismaBlockResult; + beforeBlockStateTransitions: PrismaStateTransition[]; + result: PrismaBlockResult & { + afterBlockStateTransitions: PrismaStateTransition[]; + }; } & { transactions: (PrismaTransactionExecutionResult & { tx: PrismaTransaction; + stateTransitionBatch: (PrismaStateTransitionBatch & { + stateTransitions: PrismaStateTransition[]; + })[]; })[]; }; }; @@ -37,7 +47,9 @@ export class BlockFetching extends ProcessorModule { public constructor( public blockMapper: BlockMapper, public blockResultMapper: BlockResultMapper, - public transactionResultMapper: TransactionExecutionResultMapper + public transactionResultMapper: TransactionExecutionResultMapper, + private readonly stateTransitionBatchMapper: StateTransitionBatchArrayMapper, + private readonly stateTransitionMapper: StateTransitionMapper ) { super(); } @@ -63,6 +75,14 @@ export class BlockFetching extends ProcessorModule { fromMessagesHash toMessagesHash transactionsHash + StateTransitionBatch { + applied, + StateTransition { + path, + from, + to, + } + } parent { hash } @@ -73,6 +93,13 @@ export class BlockFetching extends ProcessorModule { blockHashWitness, blockStateTransitions, blockHash, + StateTransitionBatch { + StateTransition { + path, + from, + to, + } + } } transactions { stateTransitions @@ -80,6 +107,13 @@ export class BlockFetching extends ProcessorModule { status statusMessage events + StateTransitionBatch { + StateTransition { + path, + from, + to, + } + } tx { hash methodId @@ -115,13 +149,39 @@ export class BlockFetching extends ProcessorModule { return undefined; } - const block = this.blockMapper.mapIn(parsedResponse?.data.findFirstBlock); - const result = this.blockResultMapper.mapIn( - parsedResponse?.data.findFirstBlock.result - ); + const block = { + ...this.blockMapper.mapIn(parsedResponse?.data.findFirstBlock), + beforeBlockStateTransitions: + parsedResponse.data.findFirstBlock.beforeBlockStateTransitions.map( + (st) => this.stateTransitionMapper.mapIn(st) + ), + }; + const result = { + ...this.blockResultMapper.mapIn( + parsedResponse?.data.findFirstBlock.result + ), + afterBlockStateTransitions: + parsedResponse.data.findFirstBlock.result.afterBlockStateTransitions.map( + (st) => this.stateTransitionMapper.mapIn(st) + ), + }; + const transactions = parsedResponse?.data.findFirstBlock.transactions.map( (tx) => { - return this.transactionResultMapper.mapIn([tx, tx.tx]); + const txMapped = this.transactionResultMapper.mapIn([tx, tx.tx]); + const stBatch = tx.stateTransitionBatch.map< + [ + Omit< + PrismaStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" + >, + Omit[], + ] + >((batch) => [{ applied: batch.applied }, batch.stateTransitions]); + return { + ...txMapped, + stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch), + }; } ); @@ -138,7 +198,9 @@ export class BlockFetching extends ProcessorModule { ...block, transactions, }, - result, + result: { + ...result, + }, }; } From 6ee46ce11b0100229cf7ed682ad939451c50c15d Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 15:58:12 +0000 Subject: [PATCH 19/39] Make relations lowercase to be consistent --- packages/persistance/prisma/schema.prisma | 8 ++-- .../src/services/prisma/PrismaBlockStorage.ts | 42 +++++++++---------- 2 files changed, 25 insertions(+), 25 deletions(-) diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index dae2eaaae..ccf40f464 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -59,7 +59,7 @@ model StateTransitionBatch { transactionExecutionResult TransactionExecutionResult? @relation(fields: [txExecutionResultId], references: [txHash]) block Block? @relation(fields: [blockId], references: [hash]) blockResult BlockResult? @relation(fields: [blockResultId], references: [blockHash]) - StateTransition StateTransition[] + stateTransition StateTransition[] } model TransactionExecutionResult { @@ -72,7 +72,7 @@ model TransactionExecutionResult { block Block @relation(fields: [blockHash], references: [hash]) blockHash String - StateTransitionBatch StateTransitionBatch[] + stateTransitionBatch StateTransitionBatch[] } model Block { @@ -98,7 +98,7 @@ model Block { batch Batch? @relation(fields: [batchHeight], references: [height]) batchHeight Int? - StateTransitionBatch StateTransitionBatch[] + stateTransitionBatch StateTransitionBatch[] } model Batch { @@ -122,7 +122,7 @@ model BlockResult { blockHashWitness Json @db.Json block Block? @relation(fields: [blockHash], references: [hash]) - StateTransitionBatch StateTransitionBatch[] + stateTransitionBatch StateTransitionBatch[] } model Settlement { diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 52d3a1666..362c43a0e 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -53,23 +53,23 @@ export class PrismaBlockStorage transactions: { include: { tx: true, - StateTransitionBatch: { + stateTransitionBatch: { include: { - StateTransition: true, + stateTransition: true, }, }, }, }, - StateTransitionBatch: { + stateTransitionBatch: { include: { - StateTransition: true, + stateTransition: true, }, }, result: { include: { - StateTransitionBatch: { + stateTransitionBatch: { include: { - StateTransition: true, + stateTransition: true, }, }, }, @@ -85,7 +85,7 @@ export class PrismaBlockStorage txresult, txresult.tx, ]); - const stBatch = txresult.StateTransitionBatch.map< + const stBatch = txresult.stateTransitionBatch.map< [ Omit< DBStateTransitionBatch, @@ -93,7 +93,7 @@ export class PrismaBlockStorage >, Omit[], ] - >((batch) => [{ applied: batch.applied }, batch.StateTransition]); + >((batch) => [{ applied: batch.applied }, batch.stateTransition]); return { ...txExecResult, stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch), @@ -106,7 +106,7 @@ export class PrismaBlockStorage ...this.blockMapper.mapIn(dbResult), beforeBlockStateTransitions: // Each block should just have one batch of STs associated with it - dbResult.StateTransitionBatch[0].StateTransition.map((st) => + dbResult.stateTransitionBatch[0].stateTransition.map((st) => this.stateTransitionMapper.mapIn(st) ), transactions, @@ -116,7 +116,7 @@ export class PrismaBlockStorage ...this.blockResultMapper.mapIn(dbResult.result), afterBlockStateTransitions: // Each block should just have one batch of STs assoicated with it - dbResult.StateTransitionBatch[0].StateTransition.map((st) => + dbResult.stateTransitionBatch[0].stateTransition.map((st) => this.stateTransitionMapper.mapIn(st) ), } @@ -219,7 +219,7 @@ export class PrismaBlockStorage data: { afterNetworkState: encoded.afterNetworkState as Prisma.InputJsonValue, blockHashWitness: encoded.blockHashWitness as Prisma.InputJsonValue, - StateTransitionBatch: { + stateTransitionBatch: { create: batches.map(([stBatch, sts]) => { return { ...stBatch, @@ -291,23 +291,23 @@ export class PrismaBlockStorage transactions: { include: { tx: true, - StateTransitionBatch: { + stateTransitionBatch: { include: { - StateTransition: true, + stateTransition: true, }, }, }, }, - StateTransitionBatch: { + stateTransitionBatch: { include: { - StateTransition: true, + stateTransition: true, }, }, result: { include: { - StateTransitionBatch: { + stateTransitionBatch: { include: { - StateTransition: true, + stateTransition: true, }, }, }, @@ -325,7 +325,7 @@ export class PrismaBlockStorage txresult, txresult.tx, ]); - const stBatch = txresult.StateTransitionBatch.map< + const stBatch = txresult.stateTransitionBatch.map< [ Omit< DBStateTransitionBatch, @@ -333,7 +333,7 @@ export class PrismaBlockStorage >, Omit[], ] - >((batch) => [{ applied: batch.applied }, batch.StateTransition]); + >((batch) => [{ applied: batch.applied }, batch.stateTransition]); return { ...txExecResult, stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch), @@ -355,14 +355,14 @@ export class PrismaBlockStorage block: { ...decodedBlock, beforeBlockStateTransitions: - block.StateTransitionBatch[0].StateTransition.map((st) => + block.stateTransitionBatch[0].stateTransition.map((st) => this.stateTransitionMapper.mapIn(st) ), }, result: { ...this.blockResultMapper.mapIn(result), afterBlockStateTransitions: - result.StateTransitionBatch[0].StateTransition.map((st) => + result.stateTransitionBatch[0].stateTransition.map((st) => this.stateTransitionMapper.mapIn(st) ), }, From 9587a5313945efc58d2d69510a5248c98f91e08d Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 16:07:01 +0000 Subject: [PATCH 20/39] Make relations lowercase to be consistent processor --- packages/processor/src/indexer/BlockFetching.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/processor/src/indexer/BlockFetching.ts b/packages/processor/src/indexer/BlockFetching.ts index 84a5772fd..e566ec583 100644 --- a/packages/processor/src/indexer/BlockFetching.ts +++ b/packages/processor/src/indexer/BlockFetching.ts @@ -75,9 +75,9 @@ export class BlockFetching extends ProcessorModule { fromMessagesHash toMessagesHash transactionsHash - StateTransitionBatch { + stateTransitionBatch { applied, - StateTransition { + stateTransition { path, from, to, @@ -93,8 +93,8 @@ export class BlockFetching extends ProcessorModule { blockHashWitness, blockStateTransitions, blockHash, - StateTransitionBatch { - StateTransition { + stateTransitionBatch { + stateTransition { path, from, to, @@ -107,8 +107,8 @@ export class BlockFetching extends ProcessorModule { status statusMessage events - StateTransitionBatch { - StateTransition { + stateTransitionBatch { + stateTransition { path, from, to, From 50d5347e4c002da04c78695463ef7b9f4e07e87a Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 16:37:36 +0000 Subject: [PATCH 21/39] Fix type blockfetching --- packages/processor/src/indexer/BlockFetching.ts | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/packages/processor/src/indexer/BlockFetching.ts b/packages/processor/src/indexer/BlockFetching.ts index e566ec583..89941c057 100644 --- a/packages/processor/src/indexer/BlockFetching.ts +++ b/packages/processor/src/indexer/BlockFetching.ts @@ -27,9 +27,13 @@ export interface BlockFetchingConfig { export interface BlockResponse { data: { findFirstBlock: PrismaBlock & { - beforeBlockStateTransitions: PrismaStateTransition[]; + stateTransitionBatch: (PrismaStateTransitionBatch & { + stateTransitions: PrismaStateTransition[]; + })[]; result: PrismaBlockResult & { - afterBlockStateTransitions: PrismaStateTransition[]; + stateTransitionBatch: (PrismaStateTransitionBatch & { + stateTransitions: PrismaStateTransition[]; + })[]; }; } & { transactions: (PrismaTransactionExecutionResult & { @@ -152,7 +156,7 @@ export class BlockFetching extends ProcessorModule { const block = { ...this.blockMapper.mapIn(parsedResponse?.data.findFirstBlock), beforeBlockStateTransitions: - parsedResponse.data.findFirstBlock.beforeBlockStateTransitions.map( + parsedResponse.data.findFirstBlock.stateTransitionBatch[0].stateTransitions.map( (st) => this.stateTransitionMapper.mapIn(st) ), }; @@ -161,7 +165,7 @@ export class BlockFetching extends ProcessorModule { parsedResponse?.data.findFirstBlock.result ), afterBlockStateTransitions: - parsedResponse.data.findFirstBlock.result.afterBlockStateTransitions.map( + parsedResponse.data.findFirstBlock.result.stateTransitionBatch[0].stateTransitions.map( (st) => this.stateTransitionMapper.mapIn(st) ), }; From 5019cd9a7293373bf9994531b91b8f004ef39227 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 17:01:21 +0000 Subject: [PATCH 22/39] Export types for indexer --- .../src/tasks/IndexBlockTaskParameters.ts | 51 ++++++++++++++++--- .../prisma/mappers/StateTransitionMapper.ts | 14 ++--- 2 files changed, 50 insertions(+), 15 deletions(-) diff --git a/packages/indexer/src/tasks/IndexBlockTaskParameters.ts b/packages/indexer/src/tasks/IndexBlockTaskParameters.ts index 88518ca4d..c6671c7f3 100644 --- a/packages/indexer/src/tasks/IndexBlockTaskParameters.ts +++ b/packages/indexer/src/tasks/IndexBlockTaskParameters.ts @@ -2,7 +2,11 @@ import { BlockWithResult } from "@proto-kit/sequencer"; import { BlockMapper, BlockResultMapper, + StateTransitionBatchArrayMapper, + StateTransitionMapper, TransactionExecutionResultMapper, + STBatchArrayMapOut1, + STBatchArrayMapOut2, } from "@proto-kit/persistance"; import { injectable } from "tsyringe"; @@ -13,7 +17,9 @@ 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 { @@ -29,21 +35,50 @@ export class IndexBlockTaskParametersSerializer { public fromJSON(json: string): IndexBlockTaskParameters { // eslint-disable-next-line @typescript-eslint/consistent-type-assertions const parsed = JSON.parse(json) as { - block: ReturnType; - transactions: ReturnType[]; - result: ReturnType; + block: ReturnType & { + beforeBlockStateTransitions: ReturnType< + StateTransitionMapper["mapOut"] + >[]; + }; + transactions: (ReturnType & { + stateTransitionBatch: (STBatchArrayMapOut1 & { + stateTransitions: STBatchArrayMapOut2; + })[]; + })[]; + result: ReturnType & { + 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< + [STBatchArrayMapOut1, STBatchArrayMapOut2] + >((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) + ), + }, }; } } diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index 0c11b0378..e4ba57eeb 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -11,6 +11,12 @@ import { Field } from "o1js"; import { ObjectMapper } from "../../../ObjectMapper"; +export type STBatchArrayMapOut1 = Omit< + DBStateTransitionBatch, + "txExecutionResultId" | "id" | "blockId" | "blockResultId" +>; +export type STBatchArrayMapOut2 = Omit[]; + @singleton() export class StateTransitionMapper implements @@ -72,13 +78,7 @@ export class StateTransitionBatchArrayMapper public mapOut( input: StateTransitionBatch[] - ): [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][] { + ): [STBatchArrayMapOut1, STBatchArrayMapOut2][] { return input.map((stBatch) => [ { applied: stBatch.applied, From 0d0b4fe2978ea4c85a544f52ad5f1c1ca9d0cd99 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 18:29:56 +0000 Subject: [PATCH 23/39] Alias types for readability --- .../src/services/prisma/PrismaBlockStorage.ts | 10 +++------- .../services/prisma/mappers/StateTransitionMapper.ts | 8 +------- packages/processor/src/indexer/BlockFetching.ts | 10 +++------- 3 files changed, 7 insertions(+), 21 deletions(-) diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 362c43a0e..9bbea71fa 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -28,6 +28,8 @@ import { BlockMapper } from "./mappers/BlockMapper"; import { StateTransitionBatchArrayMapper, StateTransitionMapper, + STBatchArrayMapOut1, + STBatchArrayMapOut2, } from "./mappers/StateTransitionMapper"; @injectable() @@ -86,13 +88,7 @@ export class PrismaBlockStorage txresult.tx, ]); const stBatch = txresult.stateTransitionBatch.map< - [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ] + [STBatchArrayMapOut1, STBatchArrayMapOut2] >((batch) => [{ applied: batch.applied }, batch.stateTransition]); return { ...txExecResult, diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index e4ba57eeb..dcc4de20d 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -90,13 +90,7 @@ export class StateTransitionBatchArrayMapper } public mapIn( - input: [ - Omit< - DBStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ][] + input: [STBatchArrayMapOut1, STBatchArrayMapOut2][] ): StateTransitionBatch[] { return input.map((x) => ({ applied: x[0].applied, diff --git a/packages/processor/src/indexer/BlockFetching.ts b/packages/processor/src/indexer/BlockFetching.ts index 89941c057..9edb417f5 100644 --- a/packages/processor/src/indexer/BlockFetching.ts +++ b/packages/processor/src/indexer/BlockFetching.ts @@ -13,6 +13,8 @@ import { TransactionExecutionResultMapper, StateTransitionMapper, StateTransitionBatchArrayMapper, + STBatchArrayMapOut1, + STBatchArrayMapOut2, } from "@proto-kit/persistance"; import { log } from "@proto-kit/common"; import { injectable } from "tsyringe"; @@ -174,13 +176,7 @@ export class BlockFetching extends ProcessorModule { (tx) => { const txMapped = this.transactionResultMapper.mapIn([tx, tx.tx]); const stBatch = tx.stateTransitionBatch.map< - [ - Omit< - PrismaStateTransitionBatch, - "txExecutionResultId" | "id" | "blockId" | "blockResultId" - >, - Omit[], - ] + [STBatchArrayMapOut1, STBatchArrayMapOut2] >((batch) => [{ applied: batch.applied }, batch.stateTransitions]); return { ...txMapped, From db81cba66eec79cb4dcb1374a3b8e59124c21049 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 18:37:35 +0000 Subject: [PATCH 24/39] Spacing, etc --- .../src/services/prisma/mappers/TransactionMapper.ts | 1 - packages/processor/src/indexer/BlockFetching.ts | 4 +--- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts b/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts index 30d67b308..84014988d 100644 --- a/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/TransactionMapper.ts @@ -81,7 +81,6 @@ export class TransactionExecutionResultMapper events: this.eventArrayMapper.mapOut(input.events), txHash: tx.hash, }; - return [executionResult, tx]; } } diff --git a/packages/processor/src/indexer/BlockFetching.ts b/packages/processor/src/indexer/BlockFetching.ts index 9edb417f5..52bfcf593 100644 --- a/packages/processor/src/indexer/BlockFetching.ts +++ b/packages/processor/src/indexer/BlockFetching.ts @@ -198,9 +198,7 @@ export class BlockFetching extends ProcessorModule { ...block, transactions, }, - result: { - ...result, - }, + result, }; } From 250fd85f9786407faf8e1069d4b7785b234cd836 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Mon, 24 Feb 2025 19:19:08 +0000 Subject: [PATCH 25/39] Indexer fix toJson --- .../src/tasks/IndexBlockTaskParameters.ts | 32 ++++++++++++++++--- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/packages/indexer/src/tasks/IndexBlockTaskParameters.ts b/packages/indexer/src/tasks/IndexBlockTaskParameters.ts index c6671c7f3..4b85d405b 100644 --- a/packages/indexer/src/tasks/IndexBlockTaskParameters.ts +++ b/packages/indexer/src/tasks/IndexBlockTaskParameters.ts @@ -24,11 +24,33 @@ export class IndexBlockTaskParametersSerializer { 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) + ), + }, }); } From c1c6eda1a91268544027f86a0693aae59d583fc3 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 25 Feb 2025 08:56:56 +0000 Subject: [PATCH 26/39] Fix beforeBlockStateTransitions in pushBlock --- .../src/services/prisma/PrismaBlockStorage.ts | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 9bbea71fa..f88035fb1 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -162,7 +162,20 @@ export class PrismaBlockStorage encodedBlock.beforeNetworkState as Prisma.InputJsonObject, duringNetworkState: encodedBlock.duringNetworkState as Prisma.InputJsonObject, - + stateTransitionBatch: { + create: [ + { + applied: true, + stateTransition: { + createMany: { + data: block.beforeBlockStateTransitions.map((st) => + this.stateTransitionMapper.mapOut(st) + ), + }, + }, + }, + ], + }, transactions: { createMany: { data: transactions.map((tx) => { From 5b8f6a625371218ab82c4c9334a7d89d4759e7f9 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 25 Feb 2025 12:15:20 +0000 Subject: [PATCH 27/39] Add in migration --- .../20250225121428_st_batches/migration.sql | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 packages/persistance/prisma/migrations/20250225121428_st_batches/migration.sql diff --git a/packages/persistance/prisma/migrations/20250225121428_st_batches/migration.sql b/packages/persistance/prisma/migrations/20250225121428_st_batches/migration.sql new file mode 100644 index 000000000..57e158bc9 --- /dev/null +++ b/packages/persistance/prisma/migrations/20250225121428_st_batches/migration.sql @@ -0,0 +1,50 @@ +/* + 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[], + "to" TEXT[], + + 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; From ad6a1bdf5c1f5ae41625626ddf1f4d019d57633a Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 25 Feb 2025 12:18:49 +0000 Subject: [PATCH 28/39] Update port in docker-compose for lightnet --- packages/deployment/docker/lightnet/docker-compose.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/deployment/docker/lightnet/docker-compose.yml b/packages/deployment/docker/lightnet/docker-compose.yml index 093f137a5..c00d7e883 100644 --- a/packages/deployment/docker/lightnet/docker-compose.yml +++ b/packages/deployment/docker/lightnet/docker-compose.yml @@ -12,5 +12,5 @@ services: - 8080:8080 - 8181:8181 # archive endpoints - - 5432:5432 + - 5433:5432 - 8282:8282 \ No newline at end of file From 421c9adb2288433e538ffd2382a87fb2f636e746 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 25 Feb 2025 12:28:14 +0000 Subject: [PATCH 29/39] Remove plural --- packages/persistance/src/services/prisma/PrismaBlockStorage.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index f88035fb1..729cb4f97 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -208,7 +208,7 @@ export class PrismaBlockStorage await prismaClient.stateTransitionBatch.createMany({ data: stateTransitionBatches.map((batch) => ({ ...batch, - stateTransitions: { + stateTransition: { create: { data: batch.stateTransitions, }, From 05284da60f9b3615d63687c8c699a678b601f9fe Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 25 Feb 2025 12:44:18 +0000 Subject: [PATCH 30/39] Add plural to table --- .../migration.sql | 0 packages/persistance/prisma/schema.prisma | 2 +- .../src/services/prisma/PrismaBlockStorage.ts | 26 +++++++++---------- 3 files changed, 14 insertions(+), 14 deletions(-) rename packages/persistance/prisma/migrations/{20250225121428_st_batches => 20250225123606_st_batches}/migration.sql (100%) diff --git a/packages/persistance/prisma/migrations/20250225121428_st_batches/migration.sql b/packages/persistance/prisma/migrations/20250225123606_st_batches/migration.sql similarity index 100% rename from packages/persistance/prisma/migrations/20250225121428_st_batches/migration.sql rename to packages/persistance/prisma/migrations/20250225123606_st_batches/migration.sql diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index ccf40f464..ccd42db37 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -59,7 +59,7 @@ model StateTransitionBatch { transactionExecutionResult TransactionExecutionResult? @relation(fields: [txExecutionResultId], references: [txHash]) block Block? @relation(fields: [blockId], references: [hash]) blockResult BlockResult? @relation(fields: [blockResultId], references: [blockHash]) - stateTransition StateTransition[] + stateTransitions StateTransition[] } model TransactionExecutionResult { diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 729cb4f97..0fe53adcc 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -57,21 +57,21 @@ export class PrismaBlockStorage tx: true, stateTransitionBatch: { include: { - stateTransition: true, + stateTransitions: true, }, }, }, }, stateTransitionBatch: { include: { - stateTransition: true, + stateTransitions: true, }, }, result: { include: { stateTransitionBatch: { include: { - stateTransition: true, + stateTransitions: true, }, }, }, @@ -89,7 +89,7 @@ export class PrismaBlockStorage ]); const stBatch = txresult.stateTransitionBatch.map< [STBatchArrayMapOut1, STBatchArrayMapOut2] - >((batch) => [{ applied: batch.applied }, batch.stateTransition]); + >((batch) => [{ applied: batch.applied }, batch.stateTransitions]); return { ...txExecResult, stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch), @@ -102,7 +102,7 @@ export class PrismaBlockStorage ...this.blockMapper.mapIn(dbResult), beforeBlockStateTransitions: // Each block should just have one batch of STs associated with it - dbResult.stateTransitionBatch[0].stateTransition.map((st) => + dbResult.stateTransitionBatch[0].stateTransitions.map((st) => this.stateTransitionMapper.mapIn(st) ), transactions, @@ -112,7 +112,7 @@ export class PrismaBlockStorage ...this.blockResultMapper.mapIn(dbResult.result), afterBlockStateTransitions: // Each block should just have one batch of STs assoicated with it - dbResult.stateTransitionBatch[0].stateTransition.map((st) => + dbResult.stateTransitionBatch[0].stateTransitions.map((st) => this.stateTransitionMapper.mapIn(st) ), } @@ -166,7 +166,7 @@ export class PrismaBlockStorage create: [ { applied: true, - stateTransition: { + stateTransitions: { createMany: { data: block.beforeBlockStateTransitions.map((st) => this.stateTransitionMapper.mapOut(st) @@ -302,21 +302,21 @@ export class PrismaBlockStorage tx: true, stateTransitionBatch: { include: { - stateTransition: true, + stateTransitions: true, }, }, }, }, stateTransitionBatch: { include: { - stateTransition: true, + stateTransitions: true, }, }, result: { include: { stateTransitionBatch: { include: { - stateTransition: true, + stateTransitions: true, }, }, }, @@ -342,7 +342,7 @@ export class PrismaBlockStorage >, Omit[], ] - >((batch) => [{ applied: batch.applied }, batch.stateTransition]); + >((batch) => [{ applied: batch.applied }, batch.stateTransitions]); return { ...txExecResult, stateTransitions: this.stateTransitionBatchMapper.mapIn(stBatch), @@ -364,14 +364,14 @@ export class PrismaBlockStorage block: { ...decodedBlock, beforeBlockStateTransitions: - block.stateTransitionBatch[0].stateTransition.map((st) => + block.stateTransitionBatch[0].stateTransitions.map((st) => this.stateTransitionMapper.mapIn(st) ), }, result: { ...this.blockResultMapper.mapIn(result), afterBlockStateTransitions: - result.stateTransitionBatch[0].stateTransition.map((st) => + result.stateTransitionBatch[0].stateTransitions.map((st) => this.stateTransitionMapper.mapIn(st) ), }, From b586a92845152a8d3ca8911e9f869134ba1b5542 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 25 Feb 2025 17:53:34 +0000 Subject: [PATCH 31/39] Rename stateTransitions --- .../migration.sql | 0 .../src/services/prisma/PrismaBlockStorage.ts | 24 ++++++++++--------- 2 files changed, 13 insertions(+), 11 deletions(-) rename packages/persistance/prisma/migrations/{20250225123606_st_batches => 20250225125043_st_batches}/migration.sql (100%) diff --git a/packages/persistance/prisma/migrations/20250225123606_st_batches/migration.sql b/packages/persistance/prisma/migrations/20250225125043_st_batches/migration.sql similarity index 100% rename from packages/persistance/prisma/migrations/20250225123606_st_batches/migration.sql rename to packages/persistance/prisma/migrations/20250225125043_st_batches/migration.sql diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 0fe53adcc..47a94e2fb 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -205,17 +205,19 @@ export class PrismaBlockStorage })); }); - await prismaClient.stateTransitionBatch.createMany({ - data: stateTransitionBatches.map((batch) => ({ - ...batch, - stateTransition: { - create: { - data: batch.stateTransitions, - }, - }, - })), - skipDuplicates: false, - }); + await Promise.all( + stateTransitionBatches.map( + async (batch) => + await prismaClient.stateTransitionBatch.create({ + data: { + ...batch, + stateTransitions: { + create: batch.stateTransitions, + }, + }, + }) + ) + ); } public async pushResult(result: BlockResult): Promise { From 23f2b3eb43c0e2576514789aa3f5ea60c2106c1c Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 26 Feb 2025 12:32:00 +0000 Subject: [PATCH 32/39] Fixing types --- .../src/services/prisma/PrismaBlockStorage.ts | 19 +++++++++---------- .../prisma/mappers/StateTransitionMapper.ts | 12 +++++++----- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index 47a94e2fb..bbbde969a 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -205,17 +205,16 @@ export class PrismaBlockStorage })); }); - await Promise.all( - stateTransitionBatches.map( - async (batch) => - await prismaClient.stateTransitionBatch.create({ - data: { - ...batch, - stateTransitions: { - create: batch.stateTransitions, - }, + await prismaClient.$transaction( + stateTransitionBatches.map((batch) => + prismaClient.stateTransitionBatch.create({ + data: { + ...batch, + stateTransitions: { + create: batch.stateTransitions, }, - }) + }, + }) ) ); } diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index dcc4de20d..272d6336d 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -30,19 +30,19 @@ export class StateTransitionMapper ): Omit { return { path: input.path.toString(), - // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions - from: input.from.isSome + from: input.from.isSome.toBoolean() ? input.from.value.map((x: Field) => x.toString()) : [], - // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions - to: input.to.isSome ? input.to.value.map((x: Field) => x.toString()) : [], + to: input.to.isSome.toBoolean() + ? input.to.value.map((x: Field) => x.toString()) + : [], }; } public mapIn( input: Omit ): UntypedStateTransition { - return UntypedStateTransition.fromJSON({ + const ut = UntypedStateTransition.fromJSON({ path: input.path, from: { isSome: input.from.length !== 0, @@ -55,6 +55,8 @@ export class StateTransitionMapper isForcedSome: false, }, }); + ut.fromValue.forceSome(); + return ut; } } From 9237b55569522bad681428869911c256dddeabe5 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 26 Feb 2025 13:48:52 +0000 Subject: [PATCH 33/39] Change ST schema --- .../migration.sql | 2 ++ packages/persistance/prisma/schema.prisma | 12 +++++++----- .../prisma/mappers/StateTransitionMapper.ts | 18 ++++++++---------- 3 files changed, 17 insertions(+), 15 deletions(-) rename packages/persistance/prisma/migrations/{20250225125043_st_batches => 20250226134830_st_batches}/migration.sql (96%) diff --git a/packages/persistance/prisma/migrations/20250225125043_st_batches/migration.sql b/packages/persistance/prisma/migrations/20250226134830_st_batches/migration.sql similarity index 96% rename from packages/persistance/prisma/migrations/20250225125043_st_batches/migration.sql rename to packages/persistance/prisma/migrations/20250226134830_st_batches/migration.sql index 57e158bc9..cb8d04885 100644 --- a/packages/persistance/prisma/migrations/20250225125043_st_batches/migration.sql +++ b/packages/persistance/prisma/migrations/20250226134830_st_batches/migration.sql @@ -21,7 +21,9 @@ CREATE TABLE "StateTransition" ( "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") ); diff --git a/packages/persistance/prisma/schema.prisma b/packages/persistance/prisma/schema.prisma index ccd42db37..614733bc0 100644 --- a/packages/persistance/prisma/schema.prisma +++ b/packages/persistance/prisma/schema.prisma @@ -40,11 +40,13 @@ model Transaction { } model StateTransition { - id Int @id @default(autoincrement()) - batchId Int - path String - from String[] - to String[] + id Int @id @default(autoincrement()) + batchId Int + path String + from String[] + fromIsSome Boolean + to String[] + toIsSome Boolean batch StateTransitionBatch @relation(fields: [batchId], references: [id]) } diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index 272d6336d..9788f1d61 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -7,7 +7,6 @@ import { StateTransitionBatch as DBStateTransitionBatch, StateTransition as DBStateTransition, } from "@prisma/client"; -import { Field } from "o1js"; import { ObjectMapper } from "../../../ObjectMapper"; @@ -28,14 +27,13 @@ export class StateTransitionMapper public mapOut( input: UntypedStateTransition ): Omit { + const json = input.toJSON(); return { - path: input.path.toString(), - from: input.from.isSome.toBoolean() - ? input.from.value.map((x: Field) => x.toString()) - : [], - to: input.to.isSome.toBoolean() - ? input.to.value.map((x: Field) => x.toString()) - : [], + path: json.path.toString(), + from: json.from.value, + fromIsSome: json.from.isSome, + to: json.to.value, + toIsSome: json.to.isSome, }; } @@ -45,12 +43,12 @@ export class StateTransitionMapper const ut = UntypedStateTransition.fromJSON({ path: input.path, from: { - isSome: input.from.length !== 0, + isSome: input.fromIsSome, value: input.from, isForcedSome: false, }, to: { - isSome: input.to.length !== 0, + isSome: input.toIsSome, value: input.to, isForcedSome: false, }, From 9585e37f6ebfc3189281177391093d5c30dfed08 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 26 Feb 2025 14:07:59 +0000 Subject: [PATCH 34/39] Remove string --- .../src/services/prisma/mappers/StateTransitionMapper.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index 9788f1d61..1c5606ead 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -29,7 +29,7 @@ export class StateTransitionMapper ): Omit { const json = input.toJSON(); return { - path: json.path.toString(), + path: json.path, from: json.from.value, fromIsSome: json.from.isSome, to: json.to.value, From 88a23b267f59ab78f69073e254d9c0164e9ea19a Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 26 Feb 2025 15:08:02 +0000 Subject: [PATCH 35/39] Add in StMapper.test.ts and fix --- .../prisma/mappers/StateTransitionMapper.ts | 4 +-- packages/persistance/test/stMapper.test.ts | 25 +++++++++++++++++++ 2 files changed, 26 insertions(+), 3 deletions(-) create mode 100644 packages/persistance/test/stMapper.test.ts diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index 1c5606ead..4ab2c0bc3 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -40,7 +40,7 @@ export class StateTransitionMapper public mapIn( input: Omit ): UntypedStateTransition { - const ut = UntypedStateTransition.fromJSON({ + return UntypedStateTransition.fromJSON({ path: input.path, from: { isSome: input.fromIsSome, @@ -53,8 +53,6 @@ export class StateTransitionMapper isForcedSome: false, }, }); - ut.fromValue.forceSome(); - return ut; } } diff --git a/packages/persistance/test/stMapper.test.ts b/packages/persistance/test/stMapper.test.ts new file mode 100644 index 000000000..e6e954cdd --- /dev/null +++ b/packages/persistance/test/stMapper.test.ts @@ -0,0 +1,25 @@ +import "reflect-metadata"; + +import { UntypedStateTransition } from "@proto-kit/sequencer"; + +import { StateTransitionMapper } from "../src"; + +describe("StMapper", () => { + it.each([ + // { + // path: "1234", + // from: { isSome: true, value: ["12345"], isForcedSome: false }, + // to: { isSome: true, value: ["6789"], isForcedSome: false }, + // }, + { + path: "5678", + from: { isSome: false, value: [], isForcedSome: false }, + to: { isSome: false, value: [], isForcedSome: false }, + }, + ])("MapOut to MapIn", (input) => { + const untypedTransition = UntypedStateTransition.fromJSON(input); + const stMapper = new StateTransitionMapper(); + const result = stMapper.mapIn(stMapper.mapOut(untypedTransition)).toJSON(); + expect(result).toEqual(input); + }); +}); From 13fd7d94cd74ff32692e88e808895402b33790c9 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 26 Feb 2025 15:08:21 +0000 Subject: [PATCH 36/39] Fix test typo --- packages/persistance/test/stMapper.test.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/packages/persistance/test/stMapper.test.ts b/packages/persistance/test/stMapper.test.ts index e6e954cdd..340f30f75 100644 --- a/packages/persistance/test/stMapper.test.ts +++ b/packages/persistance/test/stMapper.test.ts @@ -6,11 +6,11 @@ import { StateTransitionMapper } from "../src"; describe("StMapper", () => { it.each([ - // { - // path: "1234", - // from: { isSome: true, value: ["12345"], isForcedSome: false }, - // to: { isSome: true, value: ["6789"], isForcedSome: false }, - // }, + { + path: "1234", + from: { isSome: true, value: ["12345"], isForcedSome: false }, + to: { isSome: true, value: ["6789"], isForcedSome: false }, + }, { path: "5678", from: { isSome: false, value: [], isForcedSome: false }, From c6e2d1235779f54047ac20e065f5f2b4763e6051 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 26 Feb 2025 16:22:10 +0000 Subject: [PATCH 37/39] Add tests --- packages/persistance/test/stMapper.test.ts | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/packages/persistance/test/stMapper.test.ts b/packages/persistance/test/stMapper.test.ts index 340f30f75..bb1b9a0b0 100644 --- a/packages/persistance/test/stMapper.test.ts +++ b/packages/persistance/test/stMapper.test.ts @@ -22,4 +22,24 @@ describe("StMapper", () => { const result = stMapper.mapIn(stMapper.mapOut(untypedTransition)).toJSON(); expect(result).toEqual(input); }); + it.each([ + { + path: "1234", + from: ["12345"], + fromIsSome: false, + to: ["6789"], + toIsSome: true, + }, + { + path: "5678", + from: [], + fromIsSome: false, + to: [], + toIsSome: false, + }, + ])("MapIn to MapOut", (input) => { + const stMapper = new StateTransitionMapper(); + const result = stMapper.mapOut(stMapper.mapIn(input)); + expect(result).toEqual(input); + }); }); From 1283a3b582af079140894f84ec87695a78238f4a Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Tue, 4 Mar 2025 11:07:43 +0000 Subject: [PATCH 38/39] Code review changes --- packages/persistance/src/PrismaDatabaseConnection.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/packages/persistance/src/PrismaDatabaseConnection.ts b/packages/persistance/src/PrismaDatabaseConnection.ts index 54f5cfb30..f1f9474a5 100644 --- a/packages/persistance/src/PrismaDatabaseConnection.ts +++ b/packages/persistance/src/PrismaDatabaseConnection.ts @@ -90,6 +90,8 @@ export class PrismaDatabaseConnection "Settlement", "IncomingMessageBatch", "IncomingMessageBatchTransaction", + "StateTransition", + "StateTransitionBatch", ]; await this.prismaClient.$transaction( From fcf12e08a4488c84f53a96fd83abc2c255b82560 Mon Sep 17 00:00:00 2001 From: ejMina226 <118474890+ejMina226@users.noreply.github.com> Date: Wed, 26 Mar 2025 12:19:55 +0000 Subject: [PATCH 39/39] Code review changes --- packages/indexer/src/tasks/IndexBlockTaskParameters.ts | 10 +++++----- .../src/services/prisma/PrismaBlockStorage.ts | 6 +++--- .../services/prisma/mappers/StateTransitionMapper.ts | 8 ++++---- packages/persistance/test/stMapper.test.ts | 1 + packages/processor/src/indexer/BlockFetching.ts | 6 +++--- 5 files changed, 16 insertions(+), 15 deletions(-) diff --git a/packages/indexer/src/tasks/IndexBlockTaskParameters.ts b/packages/indexer/src/tasks/IndexBlockTaskParameters.ts index 4b85d405b..9baa05a3f 100644 --- a/packages/indexer/src/tasks/IndexBlockTaskParameters.ts +++ b/packages/indexer/src/tasks/IndexBlockTaskParameters.ts @@ -5,8 +5,8 @@ import { StateTransitionBatchArrayMapper, StateTransitionMapper, TransactionExecutionResultMapper, - STBatchArrayMapOut1, - STBatchArrayMapOut2, + STBatchOutput, + STArrayOutput, } from "@proto-kit/persistance"; import { injectable } from "tsyringe"; @@ -63,8 +63,8 @@ export class IndexBlockTaskParametersSerializer { >[]; }; transactions: (ReturnType & { - stateTransitionBatch: (STBatchArrayMapOut1 & { - stateTransitions: STBatchArrayMapOut2; + stateTransitionBatch: (STBatchOutput & { + stateTransitions: STArrayOutput; })[]; })[]; result: ReturnType & { @@ -77,7 +77,7 @@ export class IndexBlockTaskParametersSerializer { const transactions = parsed.transactions.map((tx) => { const txMapped = this.transactionResultMapper.mapIn(tx); const stBatch = tx.stateTransitionBatch.map< - [STBatchArrayMapOut1, STBatchArrayMapOut2] + [STBatchOutput, STArrayOutput] >((batch) => [{ applied: batch.applied }, batch.stateTransitions]); return { ...txMapped, diff --git a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts index bbbde969a..949626182 100644 --- a/packages/persistance/src/services/prisma/PrismaBlockStorage.ts +++ b/packages/persistance/src/services/prisma/PrismaBlockStorage.ts @@ -28,8 +28,8 @@ import { BlockMapper } from "./mappers/BlockMapper"; import { StateTransitionBatchArrayMapper, StateTransitionMapper, - STBatchArrayMapOut1, - STBatchArrayMapOut2, + STBatchOutput, + STArrayOutput, } from "./mappers/StateTransitionMapper"; @injectable() @@ -88,7 +88,7 @@ export class PrismaBlockStorage txresult.tx, ]); const stBatch = txresult.stateTransitionBatch.map< - [STBatchArrayMapOut1, STBatchArrayMapOut2] + [STBatchOutput, STArrayOutput] >((batch) => [{ applied: batch.applied }, batch.stateTransitions]); return { ...txExecResult, diff --git a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts index 4ab2c0bc3..5af3d9363 100644 --- a/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts +++ b/packages/persistance/src/services/prisma/mappers/StateTransitionMapper.ts @@ -10,11 +10,11 @@ import { import { ObjectMapper } from "../../../ObjectMapper"; -export type STBatchArrayMapOut1 = Omit< +export type STBatchOutput = Omit< DBStateTransitionBatch, "txExecutionResultId" | "id" | "blockId" | "blockResultId" >; -export type STBatchArrayMapOut2 = Omit[]; +export type STArrayOutput = Omit[]; @singleton() export class StateTransitionMapper @@ -76,7 +76,7 @@ export class StateTransitionBatchArrayMapper public mapOut( input: StateTransitionBatch[] - ): [STBatchArrayMapOut1, STBatchArrayMapOut2][] { + ): [STBatchOutput, STArrayOutput][] { return input.map((stBatch) => [ { applied: stBatch.applied, @@ -88,7 +88,7 @@ export class StateTransitionBatchArrayMapper } public mapIn( - input: [STBatchArrayMapOut1, STBatchArrayMapOut2][] + input: [STBatchOutput, STArrayOutput][] ): StateTransitionBatch[] { return input.map((x) => ({ applied: x[0].applied, diff --git a/packages/persistance/test/stMapper.test.ts b/packages/persistance/test/stMapper.test.ts index bb1b9a0b0..d3a2306b8 100644 --- a/packages/persistance/test/stMapper.test.ts +++ b/packages/persistance/test/stMapper.test.ts @@ -22,6 +22,7 @@ describe("StMapper", () => { const result = stMapper.mapIn(stMapper.mapOut(untypedTransition)).toJSON(); expect(result).toEqual(input); }); + it.each([ { path: "1234", diff --git a/packages/processor/src/indexer/BlockFetching.ts b/packages/processor/src/indexer/BlockFetching.ts index 52bfcf593..e35ec5335 100644 --- a/packages/processor/src/indexer/BlockFetching.ts +++ b/packages/processor/src/indexer/BlockFetching.ts @@ -13,8 +13,8 @@ import { TransactionExecutionResultMapper, StateTransitionMapper, StateTransitionBatchArrayMapper, - STBatchArrayMapOut1, - STBatchArrayMapOut2, + STBatchOutput, + STArrayOutput, } from "@proto-kit/persistance"; import { log } from "@proto-kit/common"; import { injectable } from "tsyringe"; @@ -176,7 +176,7 @@ export class BlockFetching extends ProcessorModule { (tx) => { const txMapped = this.transactionResultMapper.mapIn([tx, tx.tx]); const stBatch = tx.stateTransitionBatch.map< - [STBatchArrayMapOut1, STBatchArrayMapOut2] + [STBatchOutput, STArrayOutput] >((batch) => [{ applied: batch.applied }, batch.stateTransitions]); return { ...txMapped,