Removed previous results from new blocks query

Author: rpanic

packages/library/src/hooks/TransactionFeeHook.ts

@@ -126,7 +126,7 @@ export class TransactionFeeHook extends ProvableTransactionHook<TransactionFeeHo
    *
    * @param executionData
    */
-  public async onTransaction(
+  public async beforeTransaction(
     executionData: BeforeTransactionHookArguments
   ): Promise<void> {
     const feeConfig = Provable.witness(MethodFeeConfigData, () =>
@@ -159,7 +159,7 @@ export class TransactionFeeHook extends ProvableTransactionHook<TransactionFeeHo
     );
   }
 
-  public async onAfterTransaction(): Promise<void> {
+  public async afterTransaction(): Promise<void> {
     noop();
   }
 }

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

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

packages/sequencer/src/protocol/production/BatchProducerModule.ts

@@ -17,19 +17,14 @@ import { CachedStateService } from "../../state/state/CachedStateService";
 import { CachedMerkleTreeStore } from "../../state/merkle/CachedMerkleTreeStore";
 import { AsyncStateService } from "../../state/async/AsyncStateService";
 import { AsyncMerkleTreeStore } from "../../state/async/AsyncMerkleTreeStore";
-import { BlockResult, BlockWithResult } from "../../storage/model/Block";
+import { BlockWithResult } from "../../storage/model/Block";
 
 import { BlockProofSerializer } from "./tasks/serializers/BlockProofSerializer";
 import { BatchTracingService } from "./tracing/BatchTracingService";
 import { BatchFlow } from "./flow/BatchFlow";
 
 export type StateRecord = Record<string, Field[] | undefined>;
 
-export interface BlockWithPreviousResult {
-  block: BlockWithResult;
-  lastBlockResult?: BlockResult;
-}
-
 interface BatchMetadata {
   batch: SettleableBatch;
   stateService: CachedStateService;
@@ -77,7 +72,7 @@ export class BatchProducerModule extends SequencerModule {
    * be the one called by BlockTriggers
    */
   public async createBatch(
-    blocks: BlockWithPreviousResult[]
+    blocks: BlockWithResult[]
   ): Promise<SettleableBatch | undefined> {
     log.info("Producing batch...");
 
@@ -87,7 +82,7 @@ export class BatchProducerModule extends SequencerModule {
 
     if (batchWithStateDiff !== undefined) {
       const numTxs = blocks.reduce(
-        (sum, block) => sum + block.block.block.transactions.length,
+        (sum, block) => sum + block.block.transactions.length,
         0
       );
       log.info(
@@ -105,7 +100,7 @@ export class BatchProducerModule extends SequencerModule {
   }
 
   private async tryProduceBatch(
-    blocks: BlockWithPreviousResult[],
+    blocks: BlockWithResult[],
     height: number
   ): Promise<BatchMetadata | undefined> {
     if (!this.productionInProgress) {
@@ -143,14 +138,12 @@ export class BatchProducerModule extends SequencerModule {
   }
 
   private async produceBatch(
-    blocks: BlockWithPreviousResult[],
+    blocks: BlockWithResult[],
     height: number
   ): Promise<BatchMetadata | undefined> {
     const batch = await this.computeBatch(blocks, height);
 
-    const blockHashes = blocks.map((bundle) =>
-      bundle.block.block.hash.toString()
-    );
+    const blockHashes = blocks.map((bundle) => bundle.block.hash.toString());
 
     const jsonProof = this.blockProofSerializer
       .getBlockProofSerializer()
@@ -184,8 +177,7 @@ export class BatchProducerModule extends SequencerModule {
    * @private
    */
   private async computeBatch(
-    // TODO Remove previous results
-    blocks: BlockWithPreviousResult[],
+    blocks: BlockWithResult[],
     blockId: number
   ): Promise<{
     proof: Proof<BlockProverPublicInput, BlockProverPublicOutput>;
@@ -206,14 +198,14 @@ export class BatchProducerModule extends SequencerModule {
     };
 
     const trace = await this.batchTraceService.traceBatch(
-      blocks.map((block) => block.block),
+      blocks.map((block) => block),
       stateServices
     );
 
     const proof = await this.batchFlow.executeBatch(trace, blockId);
 
-    const fromNetworkState = blocks[0].block.block.networkState.before;
-    const toNetworkState = blocks.at(-1)!.block.result.afterNetworkState;
+    const fromNetworkState = blocks[0].block.networkState.before;
+    const toNetworkState = blocks.at(-1)!.result.afterNetworkState;
 
     return {
       proof,

packages/sequencer/src/storage/inmemory/InMemoryBlockStorage.ts

@@ -6,7 +6,6 @@ import {
   BlockStorage,
 } from "../repositories/BlockStorage";
 import type { Block, BlockResult, BlockWithResult } from "../model/Block";
-import { BlockWithPreviousResult } from "../../protocol/production/BatchProducerModule";
 import { BatchStorage } from "../repositories/BatchStorage";
 
 @injectable()
@@ -42,7 +41,7 @@ export class InMemoryBlockStorage
     };
   }
 
-  public async getNewBlocks(): Promise<BlockWithPreviousResult[]> {
+  public async getNewBlocks(): Promise<BlockWithResult[]> {
     const latestBatch = await this.batchStorage.getLatestBatch();
 
     let cursor = 0;
@@ -66,11 +65,8 @@ export class InMemoryBlockStorage
     }
 
     return slice.map((block, index) => ({
-      block: {
-        block,
-        result: results[index + 1]!,
-      },
-      lastBlockResult: results[index],
+      block,
+      result: results[index + 1]!,
     }));
   }
 

packages/sequencer/src/storage/repositories/BlockStorage.ts

@@ -1,10 +1,9 @@
-import { BlockWithPreviousResult } from "../../protocol/production/BatchProducerModule";
 import type { Block, BlockResult, BlockWithResult } from "../model/Block";
 
 export interface BlockQueue {
   pushBlock: (block: Block) => Promise<void>;
   pushResult: (result: BlockResult) => Promise<void>;
-  getNewBlocks: () => Promise<BlockWithPreviousResult[]>;
+  getNewBlocks: () => Promise<BlockWithResult[]>;
   getLatestBlock: () => Promise<BlockWithResult | undefined>;
 }