feat: implement get events

packages/automated-dispute/src/exceptions/index.ts

@@ -16,3 +16,4 @@ export * from "./transactionExecutionError.exception.js";
 export * from "./invalidAccountOnClient.exception.js";
 export * from "./unsupportedEvent.exception.js";
 export * from "./decodeLogDataFailure.js";
+export * from "./invalidBlockRangeError.exception.js";

packages/automated-dispute/src/exceptions/invalidBlockRangeError.exception.ts

@@ -0,0 +1,8 @@
+export class InvalidBlockRangeError extends Error {
+    constructor(fromBlock: bigint, toBlock: bigint) {
+        super(
+            `Invalid block range: fromBlock (${fromBlock}) must be less than or equal to toBlock (${toBlock})`,
+        );
+        this.name = "InvalidBlockRangeError";
+    }
+}

packages/automated-dispute/src/interfaces/protocolProvider.ts

@@ -1,4 +1,4 @@
-import { Caip2ChainId } from "@ebo-agent/blocknumber";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/src/index.js";
 import { Address } from "viem";
 
 import type {

packages/automated-dispute/src/providers/protocolProvider.ts

@@ -1,4 +1,4 @@
-import { Caip2ChainId, Caip2Utils, InvalidChainId } from "@ebo-agent/blocknumber";
+import { Caip2ChainId, Caip2Utils, InvalidChainId } from "@ebo-agent/blocknumber/src/index.js";
 import {
     AbiEvent,
     Address,
@@ -41,6 +41,7 @@ import {
 import {
     DecodeLogDataFailure,
     InvalidAccountOnClient,
+    InvalidBlockRangeError,
     RpcUrlsEmpty,
     TransactionExecutionError,
     UnsupportedEvent,
@@ -284,7 +285,7 @@ export class ProtocolProvider implements IProtocolProvider {
                 data: log.data,
                 topics: log.topics,
                 eventName,
-                strict: false,
+                strict: true,
             });
 
             return decodedLog.args as DecodedLogArgsMap[TEventName];
@@ -301,87 +302,39 @@ export class ProtocolProvider implements IProtocolProvider {
      * @returns An EboEvent object.
      */
     private parseOracleEvent(eventName: EboEventName, log: Log) {
-        if (
-            ![
-                "ResponseProposed",
-                "ResponseDisputed",
-                "DisputeStatusChanged",
-                "DisputeEscalated",
-                "RequestFinalized",
-            ].includes(eventName)
-        ) {
-            throw new UnsupportedEvent(`Unsupported event name: ${eventName}`);
-        }
-
         const baseEvent = {
             name: eventName,
-            blockNumber: log.blockNumber ?? BigInt(0),
-            logIndex: log.logIndex ?? 0,
+            blockNumber: log.blockNumber,
+            logIndex: log.logIndex,
             rawLog: log,
-            requestId: log.topics[1] as RequestId,
         };
 
         const decodedLog = this.decodeLogData(eventName, log);
 
+        let requestId: RequestId;
         switch (eventName) {
             case "ResponseProposed":
-                const responseProposedArgs = decodedLog as DecodedLogArgsMap["ResponseProposed"];
-                return {
-                    ...baseEvent,
-                    metadata: {
-                        requestId: responseProposedArgs.requestId,
-                        responseId: responseProposedArgs.responseId,
-                        response: responseProposedArgs.response,
-                        blockNumber: responseProposedArgs.blockNumber,
-                    },
-                };
+                requestId = decodedLog.requestId;
+                break;
             case "ResponseDisputed":
-                const responseDisputedArgs = decodedLog as DecodedLogArgsMap["ResponseDisputed"];
-                return {
-                    ...baseEvent,
-                    metadata: {
-                        responseId: responseDisputedArgs.responseId,
-                        disputeId: responseDisputedArgs.disputeId,
-                        dispute: responseDisputedArgs.dispute,
-                        blockNumber: responseDisputedArgs.blockNumber,
-                    },
-                };
+                requestId = decodedLog.requestId;
+                break;
             case "DisputeStatusChanged":
-                const disputeStatusChangedArgs =
-                    decodedLog as DecodedLogArgsMap["DisputeStatusChanged"];
-                return {
-                    ...baseEvent,
-                    metadata: {
-                        disputeId: disputeStatusChangedArgs.disputeId,
-                        dispute: disputeStatusChangedArgs.dispute,
-                        status: disputeStatusChangedArgs.status,
-                        blockNumber: disputeStatusChangedArgs.blockNumber,
-                    },
-                };
             case "DisputeEscalated":
-                const disputeEscalatedArgs = decodedLog as DecodedLogArgsMap["DisputeEscalated"];
-                return {
-                    ...baseEvent,
-                    metadata: {
-                        caller: disputeEscalatedArgs.caller,
-                        disputeId: disputeEscalatedArgs.disputeId,
-                        blockNumber: disputeEscalatedArgs.blockNumber,
-                    },
-                };
+                requestId = decodedLog.requestId;
+                break;
             case "RequestFinalized":
-                const requestFinalizedArgs = decodedLog as DecodedLogArgsMap["RequestFinalized"];
-                return {
-                    ...baseEvent,
-                    metadata: {
-                        requestId: requestFinalizedArgs.requestId,
-                        responseId: requestFinalizedArgs.responseId,
-                        caller: requestFinalizedArgs.caller,
-                        blockNumber: requestFinalizedArgs.blockNumber,
-                    },
-                };
+                requestId = decodedLog.requestId;
+                break;
             default:
-                throw new UnsupportedEvent(`Unsupported event name: ${eventName}`);
+                throw new Error(`Unsupported event name: ${eventName}`);
         }
+
+        return {
+            ...baseEvent,
+            requestId,
+            metadata: decodedLog,
+        };
     }
 
     /**
@@ -399,31 +352,30 @@ export class ProtocolProvider implements IProtocolProvider {
             "DisputeEscalated",
             "RequestFinalized",
         ];
-        const eventPromises = eventNames.map((eventName) =>
-            this.readClient.getLogs({
-                address: this.oracleContract.address,
-                event: oracleAbi.find(
-                    (e) => e.name === eventName && e.type === "event",
-                ) as AbiEvent,
-                fromBlock,
-                toBlock,
-            }),
-        );
 
-        const allLogs = await Promise.all(eventPromises);
-        return allLogs.flatMap((logs: Log[], index: number) =>
-            logs.map((log) => this.parseOracleEvent(eventNames[index] as EboEventName, log)),
-        );
-    }
+        const logs = await this.readClient.getLogs({
+            address: this.oracleContract.address,
+            events: eventNames.map(
+                (eventName) =>
+                    oracleAbi.find((e) => e.name === eventName && e.type === "event") as AbiEvent,
+            ),
+            fromBlock,
+            toBlock,
+            strict: true,
+        });
 
+        return logs.map((log) => {
+            const eventName = log.eventName as EboEventName;
+            return this.parseOracleEvent(eventName, log);
+        });
+    }
     /**
      * Fetches events from the EBORequestCreator contract.
      *
      * @param fromBlock - The starting block number to fetch events from.
      * @param toBlock - The ending block number to fetch events to.
      * @returns A promise that resolves to an array of EboEvents.
      */
-
     private async getEBORequestCreatorEvents(fromBlock: bigint, toBlock: bigint) {
         const logs = await this.readClient.getLogs({
             address: this.eboRequestCreatorContract.address,
@@ -441,15 +393,11 @@ export class ProtocolProvider implements IProtocolProvider {
             ) as DecodedLogArgsMap["RequestCreated"];
             return {
                 name: "RequestCreated" as const,
-                blockNumber: log.blockNumber ?? BigInt(0),
-                logIndex: log.logIndex ?? 0,
+                blockNumber: log.blockNumber,
+                logIndex: log.logIndex,
                 rawLog: log,
-                requestId: decodedLog.requestId,
-                metadata: {
-                    epoch: decodedLog.epoch,
-                    chainId: decodedLog.chainId,
-                    requestId: decodedLog.requestId,
-                },
+                requestId: decodedLog.requestId ?? "",
+                metadata: decodedLog,
             };
         });
     }
@@ -464,7 +412,7 @@ export class ProtocolProvider implements IProtocolProvider {
      */
     async getEvents(fromBlock: bigint, toBlock: bigint) {
         if (fromBlock > toBlock) {
-            throw new Error("Invalid block range: fromBlock must be less than or equal to toBlock");
+            throw new InvalidBlockRangeError(fromBlock, toBlock);
         }
 
         const [requestCreatorEvents, oracleEvents] = await Promise.all([
@@ -487,11 +435,11 @@ export class ProtocolProvider implements IProtocolProvider {
         return streams
             .reduce((acc, curr) => acc.concat(curr), [])
             .sort((a, b) => {
-                if (a.blockNumber < b.blockNumber) return 1;
-                if (a.blockNumber > b.blockNumber) return -1;
+                if (a.blockNumber > b.blockNumber) return 1;
+                if (a.blockNumber < b.blockNumber) return -1;
 
-                if (a.logIndex < b.logIndex) return 1;
-                if (a.logIndex > b.logIndex) return -1;
+                if (a.logIndex > b.logIndex) return 1;
+                if (a.logIndex < b.logIndex) return -1;
 
                 return 0;
             });

packages/automated-dispute/src/services/eboActor.ts

@@ -1,4 +1,5 @@
-import { BlockNumberService, Caip2ChainId } from "@ebo-agent/blocknumber";
+import { BlockNumberService } from "@ebo-agent/blocknumber";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/src/index.js";
 import { Address, ILogger } from "@ebo-agent/shared";
 import { Mutex } from "async-mutex";
 import { Heap } from "heap-js";
@@ -610,6 +611,7 @@ export class EboActor {
         const disputer = this.protocolProvider.getAccountAddress();
         const dispute: Dispute["prophetData"] = {
             disputer: disputer,
+            // TODO: populate proposer if does not exist on eventResponse
             proposer: eventResponse.proposer,
             responseId: Address.normalize(event.metadata.responseId) as ResponseId,
             requestId: request.id,

packages/automated-dispute/src/services/eboProcessor.ts

@@ -1,5 +1,6 @@
 import { isNativeError } from "util/types";
-import { BlockNumberService, Caip2ChainId } from "@ebo-agent/blocknumber";
+import { BlockNumberService } from "@ebo-agent/blocknumber";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/src/index.js";
 import { Address, EBO_SUPPORTED_CHAIN_IDS, ILogger } from "@ebo-agent/shared";
 
 import { PendingModulesApproval, ProcessorAlreadyStarted } from "../exceptions/index.js";

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

@@ -1,4 +1,4 @@
-import { Caip2ChainId } from "@ebo-agent/blocknumber";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/src/index.js";
 
 import { RequestId } from "./prophet.js";
 

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

@@ -1,15 +1,7 @@
-import { Caip2ChainId } from "@ebo-agent/blocknumber";
-import { Address, Hex, Log } from "viem";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/src/index.js";
+import { Address, Log } from "viem";
 
-import {
-    Dispute,
-    DisputeId,
-    DisputeStatus,
-    Request,
-    RequestId,
-    Response,
-    ResponseId,
-} from "./prophet.js";
+import { DisputeId, DisputeStatus, RequestId, ResponseId } from "./prophet.js";
 
 export type EboEventName =
     | "RequestCreated"
@@ -19,34 +11,31 @@ export type EboEventName =
     | "DisputeEscalated"
     | "RequestFinalized";
 
-export interface ResponseProposed {
-    requestId: Hex;
-    responseId: Hex;
-    response: Response["prophetData"];
-    // TODO: block number?
-}
-
 export interface RequestCreated {
+    requestId: RequestId;
     epoch: bigint;
     chainId: Caip2ChainId;
-    //TODO: remove request?
-    request: Request["prophetData"];
+}
+
+export interface ResponseProposed {
     requestId: RequestId;
+    responseId: ResponseId;
+    response: string;
+    blockNumber: bigint;
 }
 
 export interface ResponseDisputed {
     responseId: ResponseId;
     disputeId: DisputeId;
-    dispute: Dispute["prophetData"];
-    //TODO: block number?
+    dispute: string;
+    blockNumber: bigint;
 }
 
 export interface DisputeStatusChanged {
     disputeId: DisputeId;
-    dispute: Dispute["prophetData"];
+    dispute: string;
     status: DisputeStatus;
     blockNumber: bigint;
-    //TODO: should be disputeId, request, response,dispute?
 }
 
 export interface DisputeEscalated {

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

@@ -1,4 +1,4 @@
-import { Caip2ChainId } from "@ebo-agent/blocknumber";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/src/index.js";
 import { Branded, NormalizedAddress } from "@ebo-agent/shared";
 import { Address, Hex } from "viem";
 

packages/automated-dispute/tests/services/protocolProvider.spec.ts

@@ -1,4 +1,4 @@
-import { Caip2ChainId } from "@ebo-agent/blocknumber";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/src/index.js";
 import {
     ContractFunctionRevertedError,
     createPublicClient,
@@ -994,8 +994,8 @@ describe("ProtocolProvider", () => {
             ];
 
             const mockOracleEvents = [
-                { name: "ResponseProposed", blockNumber: 2n, logIndex: 0 },
-                { name: "ResponseDisputed", blockNumber: 2n, logIndex: 1 },
+                { name: "ResponseDisputed", blockNumber: 2n, logIndex: 0 },
+                { name: "ResponseProposed", blockNumber: 2n, logIndex: 1 },
             ];
 
             vi.spyOn(protocolProvider as any, "getEBORequestCreatorEvents").mockResolvedValue(
@@ -1008,23 +1008,11 @@ describe("ProtocolProvider", () => {
             const result = await protocolProvider.getEvents(0n, 100n);
 
             expect(result).toEqual([
-                { name: "RequestCreated", blockNumber: 3n, logIndex: 0 },
-                { name: "ResponseDisputed", blockNumber: 2n, logIndex: 1 },
-                { name: "ResponseProposed", blockNumber: 2n, logIndex: 0 },
                 { name: "RequestCreated", blockNumber: 1n, logIndex: 0 },
+                { name: "ResponseDisputed", blockNumber: 2n, logIndex: 0 },
+                { name: "ResponseProposed", blockNumber: 2n, logIndex: 1 },
+                { name: "RequestCreated", blockNumber: 3n, logIndex: 0 },
             ]);
         });
-
-        it("throws an error if fromBlock is greater than toBlock", async () => {
-            const protocolProvider = new ProtocolProvider(
-                mockRpcConfig,
-                mockContractAddress,
-                mockedPrivateKey,
-            );
-
-            await expect(protocolProvider.getEvents(100n, 0n)).rejects.toThrow(
-                "Invalid block range: fromBlock must be less than or equal to toBlock",
-            );
-        });
     });
 });