feat: build onRequestCreated

packages/automated-dispute/package.json

@@ -17,7 +17,8 @@
     "author": "",
     "license": "ISC",
     "dependencies": {
-        "viem": "2.17.11",
-        "@ebo-agent/blocknumber": "workspace:*"
+        "@ebo-agent/blocknumber": "workspace:*",
+        "@ebo-agent/shared": "workspace:*",
+        "viem": "2.17.11"
     }
 }

packages/automated-dispute/src/eboActor.ts

@@ -1,23 +1,48 @@
 import { BlockNumberService } from "@ebo-agent/blocknumber";
 
+import { EboRegistry } from "./eboRegistry.js";
+import { RequestMismatch } from "./exceptions/requestMismatch.js";
 import { ProtocolProvider } from "./protocolProvider.js";
 import { EboEvent } from "./types/events.js";
 import { Dispute, Response } from "./types/prophet.js";
 
 export class EboActor {
-    private requestActivity: unknown[];
+    private registry: EboRegistry;
 
     constructor(
         private readonly protocolProvider: ProtocolProvider,
         private readonly blockNumberService: BlockNumberService,
         private readonly requestId: string,
     ) {
-        this.requestActivity = [];
+        this.registry = new EboRegistry();
     }
 
-    public async onRequestCreated(_event: EboEvent<"RequestCreated">): Promise<void> {
-        // TODO: implement
-        return;
+    /**
+     * Handle RequestCreated event.
+     *
+     * @param event RequestCreated event
+     */
+    public async onRequestCreated(event: EboEvent<"RequestCreated">): Promise<void> {
+        if (event.metadata.requestId != this.requestId)
+            throw new RequestMismatch(this.requestId, event.metadata.requestId);
+
+        this.registry.addRequest(event.metadata.requestId, event.metadata.request);
+
+        const { chainId } = event.metadata;
+        const { currentEpoch, currentEpochTimestamp } =
+            await this.protocolProvider.getCurrentEpoch();
+
+        const epochBlockNumber = await this.blockNumberService.getEpochBlockNumber(
+            currentEpochTimestamp,
+            chainId,
+        );
+
+        await this.protocolProvider.proposeResponse(
+            this.requestId,
+            currentEpoch,
+            chainId,
+            epochBlockNumber,
+        );
     }
 
     public async onResponseProposed(_event: EboEvent<"ResponseDisputed">): Promise<void> {

packages/automated-dispute/src/eboRegistry.ts

@@ -0,0 +1,23 @@
+import { Dispute, Request, Response } from "./types/prophet.js";
+
+export class EboRegistry {
+    private requests: Map<string, Request>;
+    private responses: Map<string, Response>;
+    private dispute: Map<string, Dispute>;
+
+    constructor() {
+        this.requests = new Map();
+        this.responses = new Map();
+        this.dispute = new Map();
+    }
+
+    /**
+     * Add a `Request` by ID.
+     *
+     * @param requestId the ID of the `Request`
+     * @param request the `Request`
+     */
+    public addRequest(requestId: string, request: Request) {
+        this.requests.set(requestId, request);
+    }
+}

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

@@ -0,0 +1,6 @@
+export class RequestMismatch extends Error {
+    constructor(requestId: string, eventRequestId: string) {
+        super(`Actor handling request ${requestId} received a request ${eventRequestId} event.`);
+        this.name = "RequestMismatch";
+    }
+}

packages/automated-dispute/src/protocolProvider.ts

@@ -1,3 +1,5 @@
+import { Caip2ChainId } from "@ebo-agent/blocknumber/dist/types.js";
+import { Timestamp } from "@ebo-agent/shared";
 import {
     Address,
     createPublicClient,
@@ -53,17 +55,28 @@ export class ProtocolProvider {
     }
 
     /**
-     * Gets the current epoch and the block number of the current epoch
-     * @returns The current epoch and the block number of the current epoch
+     * Gets the current epoch, the block number and its timestamp of the current epoch
+     *
+     * @returns The current epoch, its block number and its timestamp
      */
-    async getCurrentEpoch(): Promise<{ currentEpoch: bigint; currentEpochBlock: bigint }> {
-        const [currentEpoch, currentEpochBlock] = await Promise.all([
+    async getCurrentEpoch(): Promise<{
+        currentEpoch: bigint;
+        currentEpochBlockNumber: bigint;
+        currentEpochTimestamp: Timestamp;
+    }> {
+        const [currentEpoch, currentEpochBlockNumber] = await Promise.all([
             this.epochManagerContract.read.currentEpoch(),
             this.epochManagerContract.read.currentEpochBlock(),
         ]);
+
+        const currentEpochBlock = await this.client.getBlock({
+            blockNumber: currentEpochBlockNumber,
+        });
+
         return {
             currentEpoch,
-            currentEpochBlock,
+            currentEpochBlockNumber,
+            currentEpochTimestamp: currentEpochBlock.timestamp,
         };
     }
 
@@ -79,6 +92,8 @@ export class ProtocolProvider {
                 logIndex: 1,
                 metadata: {
                     requestId: "0x01",
+                    chainId: "eip155:1",
+                    epoch: 1n,
                     request: {
                         requester: "0x12345678901234567890123456789012",
                         requestModule: "0x12345678901234567890123456789012",
@@ -173,7 +188,12 @@ export class ProtocolProvider {
         return;
     }
 
-    async proposeResponse(_request: Request, _response: Response): Promise<void> {
+    async proposeResponse(
+        _requestId: string,
+        _epoch: bigint,
+        _chainId: Caip2ChainId,
+        _blockNumber: bigint,
+    ): Promise<void> {
         // TODO: implement actual method
         return;
     }

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

@@ -1,6 +1,7 @@
+import { Caip2ChainId } from "@ebo-agent/blocknumber/dist/types.js";
 import { Log } from "viem";
 
-import { Dispute, Request } from "./prophet.js";
+import { Dispute, Request, Response } from "./prophet.js";
 
 export type EboEventName =
     | "NewEpoch"
@@ -17,14 +18,17 @@ export interface NewEpoch {
     epochBlockNumber: bigint;
 }
 
-export interface ResponseCreated {
+export interface ResponseProposed {
     requestId: string;
-    request: Request;
+    responseId: string;
+    response: Response;
 }
 
 export interface RequestCreated {
-    requestId: string;
+    epoch: bigint;
+    chainId: Caip2ChainId;
     request: Request;
+    requestId: string;
 }
 
 export interface ResponseDisputed {
@@ -60,8 +64,8 @@ export type EboEventData<E extends EboEventName> = E extends "NewEpoch"
     ? NewEpoch
     : E extends "RequestCreated"
       ? RequestCreated
-      : E extends "ResponseCreated"
-        ? ResponseCreated
+      : E extends "ResponseProposed"
+        ? ResponseProposed
         : E extends "ResponseDisputed"
           ? ResponseDisputed
           : E extends "DisputeStatusChanged"

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

@@ -13,7 +13,7 @@ export interface Request {
 export interface Response {
     proposer: Address;
     requestId: string;
-    response: Uint8Array;
+    response: string;
 }
 
 export interface Dispute {

packages/automated-dispute/tests/eboActor.spec.ts

@@ -1,7 +1,123 @@
-import { describe } from "vitest";
+import { BlockNumberService } from "@ebo-agent/blocknumber";
+import { Caip2ChainId } from "@ebo-agent/blocknumber/dist/types.js";
+import { Logger } from "@ebo-agent/shared";
+import { Address } from "viem";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { EboActor } from "../src/eboActor.js";
+import { RequestMismatch } from "../src/exceptions/requestMismatch.js";
+import { ProtocolProvider } from "../src/protocolProvider.js";
+import { EboEvent } from "../src/types/events.js";
+
+const logger = Logger.getInstance();
+
+const protocolContracts = {
+    oracle: "0x123456" as Address,
+    epochManager: "0x654321" as Address,
+};
 
 describe("EboActor", () => {
-    describe.skip("onRequestCreated");
+    describe("onRequestCreated", () => {
+        const requestId: Address = "0x12345";
+        const indexedChainId: Caip2ChainId = "eip155:137";
+
+        const protocolEpoch = {
+            currentEpoch: 1n,
+            currentEpochBlockNumber: 1n,
+            currentEpochTimestamp: BigInt(Date.UTC(2024, 1, 1, 0, 0, 0, 0)),
+        };
+
+        const requestCreatedEvent: EboEvent<"RequestCreated"> = {
+            blockNumber: 34n,
+            logIndex: 1,
+            name: "RequestCreated",
+            metadata: {
+                chainId: "eip155:10",
+                epoch: protocolEpoch.currentEpoch,
+                requestId: requestId,
+            },
+        };
+
+        let protocolProvider: ProtocolProvider;
+        let blockNumberService: BlockNumberService;
+
+        beforeEach(() => {
+            protocolProvider = new ProtocolProvider(["http://localhost:8538"], protocolContracts);
+
+            const chainRpcUrls = new Map<Caip2ChainId, string[]>();
+            chainRpcUrls.set(indexedChainId, ["http://localhost:8539"]);
+
+            blockNumberService = new BlockNumberService(chainRpcUrls, logger);
+        });
+
+        it("proposes a response", async () => {
+            const indexedEpochBlockNumber = 48n;
+
+            vi.spyOn(protocolProvider, "getCurrentEpoch").mockResolvedValue(protocolEpoch);
+            vi.spyOn(blockNumberService, "getEpochBlockNumber").mockResolvedValue(
+                indexedEpochBlockNumber,
+            );
+
+            const proposeResponseMock = vi.spyOn(protocolProvider, "proposeResponse");
+
+            proposeResponseMock.mockImplementation(
+                (
+                    _requestId: string,
+                    _epoch: bigint,
+                    _chainId: Caip2ChainId,
+                    _blockNumbre: bigint,
+                ) => Promise.resolve(),
+            );
+
+            const actor = new EboActor(protocolProvider, blockNumberService, requestId);
+
+            await actor.onRequestCreated(requestCreatedEvent);
+
+            expect(proposeResponseMock).toHaveBeenCalledWith(
+                requestCreatedEvent.metadata.requestId,
+                protocolEpoch.currentEpoch,
+                requestCreatedEvent.metadata.chainId,
+                indexedEpochBlockNumber,
+            );
+        });
+
+        it("throws if the event's request id does not match with actor's", () => {
+            const noMatchRequestCreatedEvent: EboEvent<"RequestCreated"> = {
+                blockNumber: 34n,
+                logIndex: 1,
+                name: "RequestCreated",
+                metadata: {
+                    chainId: "eip155:10",
+                    epoch: protocolEpoch.currentEpoch,
+                    requestId: "0x000000" as Address,
+                },
+            };
+
+            const actor = new EboActor(protocolProvider, blockNumberService, requestId);
+
+            expect(actor.onRequestCreated(noMatchRequestCreatedEvent)).rejects.toBeInstanceOf(
+                RequestMismatch,
+            );
+        });
+
+        it("throws if current epoch cannot be fetched", () => {
+            vi.spyOn(protocolProvider, "getCurrentEpoch").mockRejectedValue(new Error());
+
+            const actor = new EboActor(protocolProvider, blockNumberService, requestId);
+
+            expect(actor.onRequestCreated(requestCreatedEvent)).rejects.toBeDefined();
+        });
+
+        it("throws if the indexed chain block number cannot be fetched", () => {
+            vi.spyOn(protocolProvider, "getCurrentEpoch").mockResolvedValue(protocolEpoch);
+            vi.spyOn(blockNumberService, "getEpochBlockNumber").mockRejectedValue(new Error());
+
+            const actor = new EboActor(protocolProvider, blockNumberService, requestId);
+
+            expect(actor.onRequestCreated(requestCreatedEvent)).rejects.toBeDefined();
+        });
+    });
+
     describe.skip("onResponseProposed");
     describe.skip("onResponseDisputed");
     describe.skip("onFinalizeRequest");

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

@@ -73,22 +73,28 @@ describe("ProtocolProvider", () => {
     });
     describe("getCurrentEpoch", () => {
         it("returns currentEpoch and currentEpochBlock successfully", async () => {
-            const protocolProvider = new ProtocolProvider(mockRpcUrls, mockContractAddress);
-
             const mockEpoch = BigInt(1);
             const mockEpochBlock = BigInt(12345);
+            const mockEpochTimestamp = BigInt(Date.UTC(2024, 1, 1, 0, 0, 0, 0));
+
+            (createPublicClient as Mock).mockReturnValue({
+                getBlock: vi.fn().mockResolvedValue({ timestamp: mockEpochTimestamp }),
+            });
+
+            const protocolProvider = new ProtocolProvider(mockRpcUrls, mockContractAddress);
 
             (protocolProvider["epochManagerContract"].read.currentEpoch as Mock).mockResolvedValue(
                 mockEpoch,
             );
+
             (
                 protocolProvider["epochManagerContract"].read.currentEpochBlock as Mock
             ).mockResolvedValue(mockEpochBlock);
 
             const result = await protocolProvider.getCurrentEpoch();
 
             expect(result.currentEpoch).toBe(mockEpoch);
-            expect(result.currentEpochBlock).toBe(mockEpochBlock);
+            expect(result.currentEpochBlockNumber).toBe(mockEpochBlock);
         });
         it("throws when current epoch request fails", async () => {
             const protocolProvider = new ProtocolProvider(mockRpcUrls, mockContractAddress);

packages/blocknumber/src/exceptions/unsupportedBlockNumber.ts

@@ -1,5 +1,7 @@
+import { Timestamp } from "@ebo-agent/shared";
+
 export class UnsupportedBlockNumber extends Error {
-    constructor(timestamp: bigint) {
+    constructor(timestamp: Timestamp) {
         super(`Block with null block number at ${timestamp}`);
 
         this.name = "UnsupportedBlockNumber";

packages/blocknumber/src/providers/blockNumberProvider.ts

@@ -1,3 +1,5 @@
+import { Timestamp } from "@ebo-agent/shared";
+
 export interface BlockNumberProvider {
     /**
      * Get the block number corresponding to the beginning of the epoch.
@@ -9,5 +11,5 @@ export interface BlockNumberProvider {
      *
      * @returns the corresponding block number of a chain at a specific timestamp
      */
-    getEpochBlockNumber(timestamp: number): Promise<bigint>;
+    getEpochBlockNumber(timestamp: Timestamp): Promise<bigint>;
 }