feat: Implement EBORequestCreator.createRequests function

packages/automated-dispute/src/abis/eboRequestCreator.ts

@@ -406,4 +406,4 @@ export const eboRequestCreatorAbi = [
     { type: "error", name: "EBORequestCreator_ChainNotAdded", inputs: [] },
     { type: "error", name: "EBORequestCreator_InvalidEpoch", inputs: [] },
     { type: "error", name: "EBORequestCreator_InvalidNonce", inputs: [] },
-];
+] as const;

packages/automated-dispute/src/protocolProvider.ts

@@ -2,12 +2,15 @@ import { Caip2ChainId } from "@ebo-agent/blocknumber/dist/types.js";
 import { Timestamp } from "@ebo-agent/shared";
 import {
     Address,
+    BaseError,
+    ContractFunctionRevertedError,
     createPublicClient,
     createWalletClient,
     fallback,
     FallbackTransport,
     getContract,
     GetContractReturnType,
+    Hex,
     http,
     HttpTransport,
     PublicClient,
@@ -26,20 +29,29 @@ import {
     Oracle_InvalidRequestBody,
 } from "./exceptions/index.js";
 import { RpcUrlsEmpty } from "./exceptions/rpcUrlsEmpty.exception.js";
-import { ProtocolContractsAddresses } from "./types/protocolProvider.js";
+import {
+    IProtocolProvider,
+    IReadProvider,
+    IWriteProvider,
+    ProtocolContractsAddresses,
+} from "./types/protocolProvider.js";
 
-export class ProtocolProvider {
-    private client: PublicClient<FallbackTransport<HttpTransport[]>>;
-    private walletClient: WalletClient<FallbackTransport<HttpTransport[]>>;
-    private oracleContract: GetContractReturnType<typeof oracleAbi, typeof this.client, Address>;
+export class ProtocolProvider implements IProtocolProvider {
+    private readClient: PublicClient<FallbackTransport<HttpTransport[]>>;
+    private writeClient: WalletClient<FallbackTransport<HttpTransport[]>>;
+    private oracleContract: GetContractReturnType<
+        typeof oracleAbi,
+        typeof this.readClient,
+        Address
+    >;
     private epochManagerContract: GetContractReturnType<
         typeof epochManagerAbi,
-        typeof this.client,
+        typeof this.readClient,
         Address
     >;
     private eboRequestCreatorContract: GetContractReturnType<
         typeof eboRequestCreatorAbi,
-        typeof this.walletClient,
+        typeof this.writeClient,
         Address
     >;
 
@@ -49,23 +61,19 @@ export class ProtocolProvider {
      * @param contracts The addresses of the protocol contracts that will be instantiated
      * @param privateKey The private key of the account that will be used to interact with the contracts
      */
-    constructor(
-        rpcUrls: string[],
-        contracts: ProtocolContractsAddresses,
-        privateKey: `0x${string}`,
-    ) {
+    constructor(rpcUrls: string[], contracts: ProtocolContractsAddresses, privateKey: Hex) {
         if (rpcUrls.length === 0) {
             throw new RpcUrlsEmpty();
         }
 
-        this.client = createPublicClient({
+        this.readClient = createPublicClient({
             chain: arbitrum,
             transport: fallback(rpcUrls.map((url) => http(url))),
         });
 
         const account = privateKeyToAccount(privateKey);
 
-        this.walletClient = createWalletClient({
+        this.writeClient = createWalletClient({
             chain: arbitrum,
             transport: fallback(rpcUrls.map((url) => http(url))),
             account: account,
@@ -75,23 +83,42 @@ export class ProtocolProvider {
         this.oracleContract = getContract({
             address: contracts.oracle,
             abi: oracleAbi,
-            client: this.client,
+            client: this.readClient,
         });
         this.epochManagerContract = getContract({
             address: contracts.epochManager,
             abi: epochManagerAbi,
-            client: this.client,
+            client: this.readClient,
         });
         this.eboRequestCreatorContract = getContract({
             address: contracts.eboRequestCreator,
             abi: eboRequestCreatorAbi,
             client: {
-                public: this.client,
-                wallet: this.walletClient,
+                public: this.readClient,
+                wallet: this.writeClient,
             },
         });
     }
 
+    public write: IWriteProvider = {
+        createRequest: this.createRequest.bind(this),
+        proposeResponse: this.proposeResponse.bind(this),
+        disputeResponse: this.disputeResponse.bind(this),
+        pledgeForDispute: this.pledgeForDispute.bind(this),
+        pledgeAgainstDispute: this.pledgeAgainstDispute.bind(this),
+        settleDispute: this.settleDispute.bind(this),
+        escalateDispute: this.escalateDispute.bind(this),
+        finalize: this.finalize.bind(this),
+    };
+
+    public read: IReadProvider = {
+        getCurrentEpoch: this.getCurrentEpoch.bind(this),
+        getLastFinalizedBlock: this.getLastFinalizedBlock.bind(this),
+        getEvents: this.getEvents.bind(this),
+        hasStakedAssets: this.hasStakedAssets.bind(this),
+        getAvailableChains: this.getAvailableChains.bind(this),
+    };
+
     /**
      * Gets the current epoch, the block number and its timestamp of the current epoch
      *
@@ -107,7 +134,7 @@ export class ProtocolProvider {
             this.epochManagerContract.read.currentEpochBlock(),
         ]);
 
-        const currentEpochBlock = await this.client.getBlock({
+        const currentEpochBlock = await this.readClient.getBlock({
             blockNumber: currentEpochBlockNumber,
         });
 
@@ -119,7 +146,7 @@ export class ProtocolProvider {
     }
 
     async getLastFinalizedBlock(): Promise<bigint> {
-        const { number } = await this.client.getBlock({ blockTag: "finalized" });
+        const { number } = await this.readClient.getBlock({ blockTag: "finalized" });
 
         return number;
     }
@@ -208,33 +235,69 @@ export class ProtocolProvider {
 
     // TODO: waiting for ChainId to be merged for _chains parameter
     /**
-     * Creates a new request for the specified epoch and chains.
+     * Creates a request on the EBO Request Creator contract by simulating the transaction
+     * and then executing it if the simulation is successful.
+     *
+     * This function first simulates the `createRequests` call on the EBO Request Creator contract
+     * to validate that the transaction will succeed. If the simulation is successful, the transaction
+     * is executed by the `writeContract` method of the wallet client. The function also handles any
+     * potential errors that may occur during the simulation or transaction execution.
      *
-     * @param epoch The epoch for which to create the request
-     * @param chains An array of chain IDs for which to create the request
-     * @throws {EBORequestCreator_InvalidEpoch} If the epoch is invalid
-     * @throws {Oracle_InvalidRequestBody} If the request body is invalid
-     * @throws {EBORequestModule_InvalidRequester} If the requester is invalid
-     * @throws {EBORequestCreator_ChainNotAdded} If one of the specified chains is not added
+     * @param {bigint} epoch - The epoch for which the request is being created.
+     * @param {string[]} chains - An array of chain identifiers where the request should be created.
+     * @throws {Error} Throws an error if the chains array is empty or if the transaction fails.
+     * @throws {EBORequestCreator_InvalidEpoch} Throws if the epoch is invalid.
+     * @throws {Oracle_InvalidRequestBody} Throws if the request body is invalid.
+     * @throws {EBORequestModule_InvalidRequester} Throws if the requester is invalid.
+     * @throws {EBORequestCreator_ChainNotAdded} Throws if the specified chain is not added.
+     * @returns {Promise<void>} A promise that resolves when the request is successfully created.
      */
     async createRequest(epoch: bigint, chains: string[]): Promise<void> {
+        if (chains.length === 0) {
+            throw new Error("Chains array cannot be empty");
+        }
+
         try {
-            if (!this.eboRequestCreatorContract?.write?.createRequests) {
-                throw new Error("createRequests function is not available on the ABI");
+            const { request } = await this.readClient.simulateContract({
+                address: this.eboRequestCreatorContract.address,
+                abi: eboRequestCreatorAbi,
+                functionName: "createRequests",
+                args: [epoch, chains],
+                account: this.writeClient.account,
+            });
+
+            const hash = await this.writeClient.writeContract(request);
+
+            const receipt = await this.readClient.waitForTransactionReceipt({
+                hash,
+                confirmations: 1,
+            });
+
+            if (receipt.status !== "success") {
+                throw new Error("Transaction failed");
             }
-            await this.eboRequestCreatorContract.write.createRequests([epoch, chains]);
         } catch (error) {
-            if (error instanceof EBORequestCreator_InvalidEpoch) {
-                throw new EBORequestCreator_InvalidEpoch();
-            } else if (error instanceof Oracle_InvalidRequestBody) {
-                throw new Oracle_InvalidRequestBody();
-            } else if (error instanceof EBORequestModule_InvalidRequester) {
-                throw new EBORequestModule_InvalidRequester();
-            } else if (error instanceof EBORequestCreator_ChainNotAdded) {
-                throw new EBORequestCreator_ChainNotAdded();
-            } else {
-                throw error;
+            if (error instanceof BaseError) {
+                const revertError = error.walk(
+                    (err) => err instanceof ContractFunctionRevertedError,
+                );
+                if (revertError instanceof ContractFunctionRevertedError) {
+                    const errorName = revertError.data?.errorName ?? "";
+                    switch (errorName) {
+                        case "EBORequestCreator_InvalidEpoch":
+                            throw new EBORequestCreator_InvalidEpoch();
+                        case "Oracle_InvalidRequestBody":
+                            throw new Oracle_InvalidRequestBody();
+                        case "EBORequestModule_InvalidRequester":
+                            throw new EBORequestModule_InvalidRequester();
+                        case "EBORequestCreator_ChainNotAdded":
+                            throw new EBORequestCreator_ChainNotAdded();
+                        default:
+                            throw new Error(`Unknown error: ${errorName}`);
+                    }
+                }
             }
+            throw error;
         }
     }
 

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

@@ -1,6 +1,57 @@
+import { Caip2ChainId } from "@ebo-agent/blocknumber/dist/types.js";
+import { Timestamp } from "@ebo-agent/shared";
 import { Address } from "viem";
 
+import type { EboEvent, EboEventName } from "../types/events.js";
+import type { Dispute, Request, Response } from "../types/prophet.js";
 import { ProtocolContractsNames } from "../constants.js";
 
 export type ProtocolContract = (typeof ProtocolContractsNames)[number];
 export type ProtocolContractsAddresses = Record<ProtocolContract, Address>;
+
+export interface IReadProvider {
+    getCurrentEpoch(): Promise<{
+        currentEpoch: bigint;
+        currentEpochBlockNumber: bigint;
+        currentEpochTimestamp: Timestamp;
+    }>;
+    getLastFinalizedBlock(): Promise<bigint>;
+    getEvents(_fromBlock: bigint, _toBlock: bigint): Promise<EboEvent<EboEventName>[]>;
+    hasStakedAssets(_address: Address): Promise<boolean>;
+    getAvailableChains(): Promise<string[]>;
+}
+
+export interface IWriteProvider {
+    createRequest(epoch: bigint, chains: string[]): Promise<void>;
+    proposeResponse(
+        _requestId: string,
+        _epoch: bigint,
+        _chainId: Caip2ChainId,
+        _blockNumber: bigint,
+    ): Promise<void>;
+    disputeResponse(_requestId: string, _responseId: string, _proposer: Address): Promise<void>;
+    pledgeForDispute(
+        _request: Request["prophetData"],
+        _dispute: Dispute["prophetData"],
+    ): Promise<void>;
+    pledgeAgainstDispute(
+        _request: Request["prophetData"],
+        _dispute: Dispute["prophetData"],
+    ): Promise<void>;
+    settleDispute(
+        _request: Request["prophetData"],
+        _response: Response["prophetData"],
+        _dispute: Dispute["prophetData"],
+    ): Promise<void>;
+    escalateDispute(
+        _request: Request["prophetData"],
+        _response: Response["prophetData"],
+        _dispute: Dispute["prophetData"],
+    ): Promise<void>;
+    finalize(_request: Request["prophetData"], _response: Response["prophetData"]): Promise<void>;
+}
+
+export interface IProtocolProvider {
+    write: IWriteProvider;
+    read: IReadProvider;
+}

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

@@ -2,7 +2,8 @@ import { Address } from "viem";
 
 import { Request, RequestId } from "../../src/types/prophet";
 
-export const privateKey = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+export const mockedPrivateKey =
+    "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
 
 export const DEFAULT_MOCKED_PROTOCOL_CONTRACTS = {
     oracle: "0x123456" as Address,

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

@@ -14,7 +14,7 @@ import mocks from "../mocks/index.js";
 import {
     DEFAULT_MOCKED_PROTOCOL_CONTRACTS,
     DEFAULT_MOCKED_REQUEST_CREATED_DATA,
-    privateKey,
+    mockedPrivateKey,
 } from "./fixtures.js";
 
 const logger: ILogger = mocks.mockLogger();
@@ -53,7 +53,7 @@ describe("EboActor", () => {
                 protocolProvider = new ProtocolProvider(
                     ["http://localhost:8538"],
                     DEFAULT_MOCKED_PROTOCOL_CONTRACTS,
-                    privateKey,
+                    mockedPrivateKey,
                 );
 
                 const chainRpcUrls = new Map<Caip2ChainId, string[]>();

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

@@ -10,7 +10,7 @@ import { ProtocolProvider } from "../src/protocolProvider.js";
 import {
     DEFAULT_MOCKED_PROTOCOL_CONTRACTS,
     DEFAULT_MOCKED_REQUEST_CREATED_DATA,
-    privateKey,
+    mockedPrivateKey,
 } from "./eboActor/fixtures.js";
 import mocks from "./mocks/index.js";
 
@@ -32,7 +32,7 @@ describe("EboActorsManager", () => {
         protocolProvider = new ProtocolProvider(
             protocolProviderRpcUrls,
             DEFAULT_MOCKED_PROTOCOL_CONTRACTS,
-            privateKey,
+            mockedPrivateKey,
         );
 
         const blockNumberRpcUrls = new Map<Caip2ChainId, string[]>([

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

@@ -7,7 +7,7 @@ import { EboActor } from "../../src/eboActor.js";
 import { ProtocolProvider } from "../../src/protocolProvider.js";
 import { EboMemoryRegistry } from "../../src/services/index.js";
 import { Dispute, Request, Response } from "../../src/types/index.js";
-import { DEFAULT_MOCKED_PROTOCOL_CONTRACTS, privateKey } from "../eboActor/fixtures.js";
+import { DEFAULT_MOCKED_PROTOCOL_CONTRACTS, mockedPrivateKey } from "../eboActor/fixtures.js";
 
 /**
  * Builds a base `EboActor` scaffolded with all its dependencies.
@@ -23,7 +23,7 @@ export function buildEboActor(request: Request, logger: ILogger) {
     const protocolProvider = new ProtocolProvider(
         protocolProviderRpcUrls,
         DEFAULT_MOCKED_PROTOCOL_CONTRACTS,
-        privateKey,
+        mockedPrivateKey,
     );
 
     const blockNumberRpcUrls = new Map<Caip2ChainId, string[]>([

packages/automated-dispute/tests/mocks/eboProcessor.mocks.ts

@@ -5,14 +5,14 @@ import { ILogger } from "@ebo-agent/shared";
 import { EboActorsManager } from "../../src/eboActorsManager";
 import { ProtocolProvider } from "../../src/protocolProvider";
 import { EboProcessor } from "../../src/services";
-import { DEFAULT_MOCKED_PROTOCOL_CONTRACTS, privateKey } from "../eboActor/fixtures";
+import { DEFAULT_MOCKED_PROTOCOL_CONTRACTS, mockedPrivateKey } from "../eboActor/fixtures";
 
 export function buildEboProcessor(logger: ILogger) {
     const protocolProviderRpcUrls = ["http://localhost:8538"];
     const protocolProvider = new ProtocolProvider(
         protocolProviderRpcUrls,
         DEFAULT_MOCKED_PROTOCOL_CONTRACTS,
-        privateKey,
+        mockedPrivateKey,
     );
 
     const blockNumberRpcUrls = new Map<Caip2ChainId, string[]>([