Fixed linting, refactored typing

Author: rpanic

packages/sequencer/src/protocol/production/sequencing/BlockProductionService.ts

@@ -15,8 +15,13 @@ import {
 } from "@proto-kit/protocol";
 import { Field } from "o1js";
 import { log } from "@proto-kit/common";
+import { match } from "ts-pattern";
 
-import { Block, BlockWithResult } from "../../../storage/model/Block";
+import {
+  Block,
+  BlockWithResult,
+  TransactionExecutionResult,
+} from "../../../storage/model/Block";
 import { CachedStateService } from "../../../state/state/CachedStateService";
 import { PendingTransaction } from "../../../mempool/PendingTransaction";
 import { AsyncStateService } from "../../../state/async/AsyncStateService";
@@ -27,9 +32,16 @@ import { trace } from "../../../logging/trace";
 import {
   BlockTrackers,
   executeWithExecutionContext,
+  TransactionExecutionResultStatus,
   TransactionExecutionService,
 } from "./TransactionExecutionService";
 
+function isIncludedTxs(
+  x: TransactionExecutionResultStatus
+): x is { status: "included"; result: TransactionExecutionResult } {
+  return x.status === "included";
+}
+
 @injectable()
 @scoped(Lifecycle.ContainerScoped)
 export class BlockProductionService {
@@ -146,8 +158,12 @@ export class BlockProductionService {
       return undefined;
     }
 
+    const includedTransactions = executionResults
+      .filter(isIncludedTxs)
+      .map((x) => x.result);
+
     const block: Omit<Block, "hash"> = {
-      transactions: executionResults.map((x) => x.result),
+      transactions: includedTransactions,
       transactionsHash: newBlockState.transactionList.commitment,
       fromEternalTransactionsHash: lastBlock.toEternalTransactionsHash,
       toEternalTransactionsHash:
@@ -169,10 +185,17 @@ export class BlockProductionService {
 
     const hash = Block.hash(block);
 
-    const includedTxs = executionResults.map((x) => ({
-      hash: x.result.tx.hash().toString(),
-      type: x.status,
-    }));
+    const includedTxs = executionResults.map((x) => {
+      const txHash = match(x)
+        .with({ status: "included" }, ({ result }) => result.tx)
+        .otherwise(({ tx }) => tx)
+        .hash()
+        .toString();
+      return {
+        hash: txHash,
+        type: x.status,
+      };
+    });
 
     return {
       block: {

packages/sequencer/src/protocol/production/sequencing/TransactionExecutionService.ts

@@ -197,6 +197,14 @@ function traceLogSTs(msg: string, stateTransitions: StateTransition<any>[]) {
   );
 }
 
+export type TransactionExecutionResultStatus =
+  | {
+      result: TransactionExecutionResult;
+      status: "included";
+    }
+  | { tx: PendingTransaction; status: "skipped" }
+  | { tx: PendingTransaction; status: "shouldRemove" };
+
 @injectable()
 @scoped(Lifecycle.ContainerScoped)
 export class TransactionExecutionService {
@@ -319,23 +327,18 @@ export class TransactionExecutionService {
     );
   }
 
+  // eslint-disable-next-line sonarjs/cognitive-complexity
   public async createExecutionTraces(
     asyncStateService: CachedStateService,
     transactions: PendingTransaction[],
     networkState: NetworkState,
     state: BlockTrackers
   ): Promise<{
     blockState: BlockTrackers;
-    executionResults: {
-      result: TransactionExecutionResult;
-      status: "included" | "skipped" | "shouldRemove";
-    }[];
+    executionResults: TransactionExecutionResultStatus[];
   }> {
     let blockState = state;
-    const executionResults: {
-      result: TransactionExecutionResult;
-      status: "included" | "skipped" | "shouldRemove";
-    }[] = [];
+    const executionResults: TransactionExecutionResultStatus[] = [];
 
     const networkStateHash = networkState.hash();
 
@@ -367,7 +370,7 @@ export class TransactionExecutionService {
             `Error in inclusion of tx, ${actionMessage}: Protocol hooks not executable: ${executionTrace.statusMessage ?? "unknown reason"}`
           );
           executionResults.push({
-            result: executionTrace,
+            tx,
             status: shouldRemove ? "shouldRemove" : "skipped",
           });
         } else {
@@ -377,9 +380,9 @@ export class TransactionExecutionService {
           executionResults.push({ result: executionTrace, status: "included" });
         }
       } catch (error) {
-        console.log("error", error);
         if (error instanceof Error) {
-          log.error("Error in inclusion of tx, skipping", error);
+          log.error("Error in inclusion of tx, dropping", error);
+          executionResults.push({ tx, status: "shouldRemove" });
         }
       }
     }