Merge branch 'develop' into feature/static-dependency-factory

# Conflicts:
#	packages/sequencer/src/mempool/private/PrivateMempool.ts

Author: rpanic

packages/persistance/src/services/prisma/mappers/EventMapper.ts

@@ -4,45 +4,53 @@ import { Field } from "o1js";
 
 import { ObjectMapper } from "../../../ObjectMapper";
 
+type EventData = {
+  eventName: string;
+  data: Field[];
+  source: "afterTxHook" | "beforeTxHook" | "runtime";
+};
+
 @singleton()
-export class EventMapper
-  implements
-    ObjectMapper<{ eventName: string; data: Field[] }, Prisma.JsonObject>
-{
-  public mapIn(input: Prisma.JsonObject): { eventName: string; data: Field[] } {
-    if (input === undefined) return { eventName: "", data: [] };
+export class EventMapper implements ObjectMapper<EventData, Prisma.JsonObject> {
+  public mapIn(input: Prisma.JsonObject): EventData {
     return {
       eventName: input.eventName as string,
       data: (input.data as Prisma.JsonArray).map((field) =>
         Field.fromJSON(field as string)
       ),
+      source: this.sourceConvert(input.source as string),
     };
   }
 
-  public mapOut(input: {
-    eventName: string;
-    data: Field[];
-  }): Prisma.JsonObject {
+  public mapOut(input: EventData): Prisma.JsonObject {
     return {
       eventName: input.eventName,
       data: input.data.map((field) => field.toString()),
+      source: input.source,
     } as Prisma.JsonObject;
   }
+
+  private sourceConvert(input: string) {
+    if (
+      input === "beforeTxHook" ||
+      input === "afterTxHook" ||
+      input === "runtime"
+    ) {
+      return input;
+    }
+    throw new Error(
+      "Event Source must be one of 'beforeTxHook', 'afterTxHook' or 'runtime'"
+    );
+  }
 }
 
 @singleton()
 export class EventArrayMapper
-  implements
-    ObjectMapper<
-      { eventName: string; data: Field[] }[],
-      Prisma.JsonValue | undefined
-    >
+  implements ObjectMapper<EventData[], Prisma.JsonValue | undefined>
 {
   public constructor(private readonly eventMapper: EventMapper) {}
 
-  public mapIn(
-    input: Prisma.JsonValue | undefined
-  ): { eventName: string; data: Field[] }[] {
+  public mapIn(input: Prisma.JsonValue | undefined): EventData[] {
     if (input === undefined) return [];
 
     if (Array.isArray(input)) {
@@ -53,9 +61,7 @@ export class EventArrayMapper
     return [];
   }
 
-  public mapOut(
-    input: { eventName: string; data: Field[] }[]
-  ): Prisma.JsonValue {
+  public mapOut(input: EventData[]): Prisma.JsonValue {
     return input.map((event) =>
       this.eventMapper.mapOut(event)
     ) as Prisma.JsonArray;

packages/sequencer/src/mempool/private/PrivateMempool.ts

@@ -37,8 +37,15 @@ type MempoolTransactionPaths = {
   paths: Field[];
 };
 
+interface PrivateMempoolConfig {
+  validationEnabled?: boolean;
+}
+
 @sequencerModule()
-export class PrivateMempool extends SequencerModule implements Mempool {
+export class PrivateMempool
+  extends SequencerModule<PrivateMempoolConfig>
+  implements Mempool
+{
   public readonly events = new EventEmitter<MempoolEvents>();
 
   private readonly accountStateHook: AccountStateHook;
@@ -113,13 +120,16 @@ export class PrivateMempool extends SequencerModule implements Mempool {
     const networkState =
       (await this.getStagedNetworkState()) ?? NetworkState.empty();
 
-    const sortedTxs = await this.checkTxValid(
-      txs,
-      baseCachedStateService,
-      this.protocol.stateServiceProvider,
-      networkState,
-      limit
-    );
+    const validationEnabled = this.config.validationEnabled ?? true;
+    const sortedTxs = validationEnabled
+      ? await this.checkTxValid(
+          txs,
+          baseCachedStateService,
+          this.protocol.stateServiceProvider,
+          networkState,
+          limit
+        )
+      : txs;
 
     this.protocol.stateServiceProvider.popCurrentStateService();
     return sortedTxs;

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

@@ -113,22 +113,32 @@ async function decodeTransaction(
 }
 
 function extractEvents(
-  runtimeResult: RuntimeContextReducedExecutionResult
-): { eventName: string; data: Field[] }[] {
+  runtimeResult: RuntimeContextReducedExecutionResult,
+  source: "afterTxHook" | "beforeTxHook" | "runtime"
+): {
+  eventName: string;
+  data: Field[];
+  source: "afterTxHook" | "beforeTxHook" | "runtime";
+}[] {
   return runtimeResult.events.reduce(
     (acc, event) => {
       if (event.condition.toBoolean()) {
         const obj = {
           eventName: event.eventName,
           // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
           data: event.eventType.toFields(event.event),
+          source: source,
         };
         acc.push(obj);
       }
       return acc;
     },
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    [] as { eventName: string; data: Field[] }[]
+    [] as {
+      eventName: string;
+      data: Field[];
+      source: "afterTxHook" | "beforeTxHook" | "runtime";
+    }[]
   );
 }
 
@@ -323,6 +333,7 @@ export class TransactionExecutionService {
       async (hook, hookArgs) => await hook.beforeTransaction(hookArgs),
       "beforeTx"
     );
+    const beforeHookEvents = extractEvents(beforeTxHookResult, "beforeTxHook");
 
     await recordingStateService.applyStateTransitions(
       beforeTxHookResult.stateTransitions
@@ -372,6 +383,7 @@ export class TransactionExecutionService {
       async (hook, hookArgs) => await hook.afterTransaction(hookArgs),
       "afterTx"
     );
+    const afterHookEvents = extractEvents(afterTxHookResult, "afterTxHook");
     await recordingStateService.applyStateTransitions(
       afterTxHookResult.stateTransitions
     );
@@ -385,7 +397,7 @@ export class TransactionExecutionService {
     appChain.setProofsEnabled(previousProofsEnabled);
 
     // Extract sequencing results
-    const events = extractEvents(runtimeResult);
+    const runtimeResultEvents = extractEvents(runtimeResult, "runtime");
     const stateTransitions = this.buildSTBatches(
       [
         beforeTxHookResult.stateTransitions,
@@ -403,7 +415,7 @@ export class TransactionExecutionService {
         statusMessage: runtimeResult.statusMessage,
 
         stateTransitions,
-        events,
+        events: beforeHookEvents.concat(runtimeResultEvents, afterHookEvents),
       },
     ];
   }

packages/sequencer/src/storage/model/Block.ts

@@ -20,7 +20,11 @@ export interface TransactionExecutionResult {
   stateTransitions: StateTransitionBatch[];
   status: Bool;
   statusMessage?: string;
-  events: { eventName: string; data: Field[] }[];
+  events: {
+    eventName: string;
+    data: Field[];
+    source: "afterTxHook" | "beforeTxHook" | "runtime";
+  }[];
 }
 
 // TODO Why is Block using Fields, but BlockResult bigints? Align that towards the best option

packages/sequencer/test/integration/BlockProduction.test.ts

@@ -687,11 +687,13 @@ describe("block production", () => {
     const firstEventReduced = {
       eventName: firstExpectedEvent.eventName,
       data: firstExpectedEvent.eventType.toFields(firstExpectedEvent.event),
+      source: "runtime",
     };
 
     const secondEventReduced = {
       eventName: secondExpectedEvent.eventName,
       data: secondExpectedEvent.eventType.toFields(secondExpectedEvent.event),
+      source: "runtime",
     };
 
     const block = await test.produceBlock();