refactor: generic ebo events

packages/automated-dispute/src/eboActor.ts

@@ -1,12 +1,7 @@
 import { BlockNumberService } from "@ebo-agent/blocknumber";
 
 import { ProtocolProvider } from "./protocolProvider.js";
-import {
-    DisputeStatusChanged,
-    RequestCreated,
-    RequestFinalizable,
-    ResponseDisputed,
-} from "./types/events.js";
+import { EboEvent } from "./types/events.js";
 import { Dispute, Response } from "./types/prophet.js";
 
 export class EboActor {
@@ -20,17 +15,17 @@ export class EboActor {
         this.requestActivity = [];
     }
 
-    public async onRequestCreated(_event: RequestCreated): Promise<void> {
+    public async onRequestCreated(_event: EboEvent<"RequestCreated">): Promise<void> {
         // TODO: implement
         return;
     }
 
-    public async onResponseProposed(_event: ResponseDisputed): Promise<void> {
+    public async onResponseProposed(_event: EboEvent<"ResponseDisputed">): Promise<void> {
         // TODO: implement
         return;
     }
 
-    public async onResponseDisputed(_event: ResponseDisputed): Promise<void> {
+    public async onResponseDisputed(_event: EboEvent<"ResponseDisputed">): Promise<void> {
         // TODO: implement
         return;
     }
@@ -50,17 +45,18 @@ export class EboActor {
         return true;
     }
 
-    public async onFinalizeRequest(_event: RequestFinalizable): Promise<void> {
+    public async onFinalizeRequest(_event: EboEvent<"RequestFinalizable">): Promise<void> {
         // TODO: implement
         return;
     }
 
-    public async onDisputeStatusChanged(_event: DisputeStatusChanged): Promise<void> {
+    public async onDisputeStatusChanged(_event: EboEvent<"DisputeStatusChanged">): Promise<void> {
         // TODO: implement
         return;
     }
 
-    public async onDisputeEscalated(_event: Dispute): Promise<void> {
+    public async onDisputeEscalated(_event: EboEvent<"DisputeEscalated">): Promise<void> {
+        // TODO: implement
         return;
     }
 }

packages/automated-dispute/src/protocolProvider.ts

@@ -11,13 +11,7 @@ import {
 } from "viem";
 import { arbitrum } from "viem/chains";
 
-import type {
-    DisputeStatusChanged,
-    EboEvent,
-    RequestCreated,
-    ResponseDisputed,
-    ResponseProposed,
-} from "./types/events.js";
+import type { AnyEboEvent, EboEvent } from "./types/events.js";
 import type { Dispute, Request, Response } from "./types/prophet.js";
 import { epochManagerAbi, oracleAbi } from "./abis/index.js";
 import { RpcUrlsEmpty } from "./exceptions/rpcUrlsEmpty.exception.js";
@@ -73,7 +67,7 @@ export class ProtocolProvider {
         };
     }
 
-    async getEvents(_fromBlock: bigint, _toBlock: bigint): Promise<EboEvent[]> {
+    async getEvents(_fromBlock: bigint, _toBlock: bigint): Promise<AnyEboEvent[]> {
         // TODO: implement actual method.
         //
         // We should decode events using the corresponding ABI and also "fabricate" new events
@@ -94,7 +88,7 @@ export class ProtocolProvider {
                         finalityModule: "0x12345678901234567890123456789012",
                     },
                 },
-            } as RequestCreated,
+            } as EboEvent<"RequestCreated">,
         ];
 
         const oracleEvents = [
@@ -111,7 +105,7 @@ export class ProtocolProvider {
                         response: "0x01234",
                     },
                 },
-            } as ResponseProposed,
+            } as EboEvent<"ResponseProposed">,
             {
                 name: "ResponseDisputed",
                 blockNumber: 3n,
@@ -127,13 +121,13 @@ export class ProtocolProvider {
                         requestId: "0x01",
                     },
                 },
-            } as ResponseDisputed,
+            } as EboEvent<"ResponseDisputed">,
             {
                 name: "DisputeStatusChanged",
                 blockNumber: 4n,
                 logIndex: 20,
                 metadata: { disputeId: "0x03", status: "Won", blockNumber: 4n },
-            } as DisputeStatusChanged,
+            } as EboEvent<"DisputeStatusChanged">,
         ];
 
         return this.mergeEventStreams(eboRequestCreatorEvents, oracleEvents);
@@ -147,7 +141,7 @@ export class ProtocolProvider {
      * @returns the EboEvent[] arrays merged in a single array and sorted by ascending blockNumber
      *  and logIndex
      */
-    private mergeEventStreams(...streams: EboEvent[][]) {
+    private mergeEventStreams(...streams: AnyEboEvent[][]) {
         return streams
             .reduce((acc, curr) => acc.concat(curr), [])
             .sort((a, b) => {

packages/automated-dispute/src/types/events.ts

@@ -1,46 +1,87 @@
 import { Log } from "viem";
 
-import { Dispute, Request, Response } from "./prophet.js";
+import { Dispute, Request } from "./prophet.js";
 
-export type BaseEvent = {
-    name: string;
-    blockNumber: bigint;
-    logIndex: number;
-    rawLog?: Log;
-    metadata: unknown;
-};
+type EventName =
+    | "NewEpoch"
+    | "RequestCreated"
+    | "ResponseProposed"
+    | "ResponseDisputed"
+    | "DisputeStatusChanged"
+    | "DisputeEscalated"
+    | "RequestFinalizable"
+    | "RequestFinalized";
 
-export type NewEpoch = BaseEvent & { metadata: { epoch: bigint; epochBlockNumber: bigint } };
+export interface NewEpoch {
+    epoch: bigint;
+    epochBlockNumber: bigint;
+}
 
-export type RequestCreated = BaseEvent & { metadata: { requestId: string; request: Request } };
+export interface ResponseCreated {
+    requestId: string;
+    request: Request;
+}
 
-export type ResponseProposed = BaseEvent & {
-    metadata: { requestId: string; responseId: string; response: Response };
-};
+export interface RequestCreated {
+    requestId: string;
+    request: Request;
+}
 
-export type ResponseDisputed = BaseEvent & {
-    metadata: { requestId: string; responseId: string; dispute: Dispute };
-};
+export interface ResponseDisputed {
+    requestId: string;
+    responseId: string;
+    dispute: Dispute;
+}
 
-export type DisputeStatusChanged = BaseEvent & {
-    metadata: { disputeId: string; status: string; blockNumber: bigint };
-};
+export interface DisputeStatusChanged {
+    disputeId: string;
+    status: string;
+    blockNumber: bigint;
+}
 
-export type DisputeEscalated = BaseEvent & {
-    metadata: { caller: string; disputeId: string; blockNumber: bigint };
-};
+export interface DisputeEscalated {
+    caller: string;
+    disputeId: string;
+    blockNumber: bigint;
+}
 
-export type RequestFinalizable = BaseEvent & {
-    metadata: { requestId: string };
-};
+export interface RequestFinalizable {
+    requestId: string;
+}
+
+export interface RequestFinalized {
+    requestId: string;
+    responseId: string;
+    caller: string;
+    blockNumber: bigint;
+}
 
-export type RequestFinalized = BaseEvent & {
-    metadata: { requestId: string; responseId: string; caller: string; blockNumber: bigint };
+export type EboEventData<E extends EventName> = E extends "NewEpoch"
+    ? NewEpoch
+    : E extends "RequestCreated"
+      ? RequestCreated
+      : E extends "ResponseCreated"
+        ? ResponseCreated
+        : E extends "ResponseDisputed"
+          ? ResponseDisputed
+          : E extends "DisputeStatusChanged"
+            ? DisputeStatusChanged
+            : E extends "DisputeEscalated"
+              ? DisputeEscalated
+              : E extends "RequestFinalizable"
+                ? RequestFinalizable
+                : E extends "RequestFinalized"
+                  ? RequestFinalized
+                  : never;
+
+export type EboEvent<T extends EventName> = {
+    name: T;
+    blockNumber: bigint;
+    logIndex: number;
+    rawLog?: Log;
+    metadata: EboEventData<T>;
 };
 
-export type EboEvent =
-    | NewEpoch
-    | RequestCreated
-    | ResponseProposed
-    | ResponseDisputed
-    | DisputeStatusChanged;
+export type AnyEboEvent = {
+    [K in EventName]: EboEvent<K>;
+}[EventName];