test: e2e dispute

apps/agent/test/e2e/utils/prophet-e2e-scaffold/eboCore.ts

@@ -9,6 +9,7 @@ import {
     createTestClient,
     createWalletClient,
     encodeFunctionData,
+    formatEther,
     http,
     HttpTransport,
     parseAbi,
@@ -226,8 +227,8 @@ interface SetUpProphetInput {
     accounts: Account[];
     /** Map of deployed contracts */
     deployedContracts: DeployContractsOutput;
-    /** Bond amount */
-    bondAmount: bigint;
+    /** GRT amount to provision account with to be able to bond tokens throughout its operation */
+    grtProvisionAmount: bigint;
     /** Arbitrator address to use to add chains into EBORequestCreator  */
     arbitratorAddress: Address;
     /** GRT address */
@@ -244,7 +245,13 @@ interface SetUpProphetInput {
  * @param input {@link SetUpProphetInput}
  */
 export async function setUpProphet(input: SetUpProphetInput) {
-    const { chainsToAdd, accounts, deployedContracts, anvilClient, bondAmount } = input;
+    const {
+        chainsToAdd,
+        accounts,
+        deployedContracts,
+        anvilClient,
+        grtProvisionAmount: bondAmount,
+    } = input;
     const { arbitratorAddress, grtAddress, horizonStakingAddress } = input;
 
     await approveEboProphetModules(accounts, deployedContracts, anvilClient);
@@ -328,7 +335,7 @@ async function stakeGrtWithProvision(
         horizonStaking: Address;
         horizonAccountingExtension: Address;
     },
-    bondSize: bigint,
+    grtProvisionAmount: bigint,
     anvilClient: AnvilClient<HttpTransport, Chain, undefined>,
 ) {
     console.log("Staking GRT into Horizon...");
@@ -343,30 +350,32 @@ async function stakeGrtWithProvision(
             to: grt,
             data: encodeFunctionData({
                 abi: parseAbi(["function approve(address, uint256)"]),
-                args: [horizonStaking, bondSize * 5n],
+                args: [horizonStaking, grtProvisionAmount],
             }),
         });
 
         await anvilClient.waitForTransactionReceipt({
             hash: approveHash,
         });
 
-        console.log(`Staking for ${account.address} ${bondSize}...`);
+        console.log(`Staking for ${account.address} ${formatEther(grtProvisionAmount)} GRT...`);
 
         const stakeHash = await anvilClient.sendTransaction({
             account: account,
             to: horizonStaking,
             data: encodeFunctionData({
                 abi: parseAbi(["function stake(uint256)"]),
-                args: [bondSize],
+                args: [grtProvisionAmount],
             }),
         });
 
         await anvilClient.waitForTransactionReceipt({
             hash: stakeHash,
         });
 
-        console.log(`Provisioning ${bondSize} for ${account.address}...`);
+        console.log(
+            `Provisioning ${account.address} with ${formatEther(grtProvisionAmount)} GRT...`,
+        );
 
         const provisionHash = await anvilClient.sendTransaction({
             account: account,
@@ -376,7 +385,7 @@ async function stakeGrtWithProvision(
                 args: [
                     account.address,
                     horizonAccountingExtension,
-                    bondSize,
+                    grtProvisionAmount,
                     // TODO: use contract call to get this value
                     // https://github.com/defi-wonderland/EBO-core/blob/175bcd57c3254a90dd6fcbf53b3db3359085551f/src/contracts/HorizonAccountingExtension.sol#L38C26-L38C42
                     1_000_000,

apps/agent/test/e2e/utils/prophet-e2e-scaffold/epochManager.ts

@@ -0,0 +1,61 @@
+import { epochManagerAbi } from "@ebo-agent/automated-dispute";
+import { Address, Chain, HttpTransport } from "viem";
+
+import { AnvilClient } from "./anvil";
+
+type SetEpochLengthInput = {
+    client: AnvilClient<HttpTransport, Chain>;
+    governorAddress: Address;
+    epochManagerAddress: Address;
+    length: bigint;
+};
+
+export const setEpochLength = async (params: SetEpochLengthInput) => {
+    const { client, governorAddress, epochManagerAddress, length } = params;
+
+    client.impersonateAccount({
+        address: governorAddress,
+    });
+
+    const tx = await client.writeContract({
+        address: epochManagerAddress,
+        account: governorAddress,
+        abi: epochManagerAbi,
+        functionName: "setEpochLength",
+        args: [length],
+    });
+
+    await client.waitForTransactionReceipt({ hash: tx });
+
+    client.stopImpersonatingAccount({
+        address: governorAddress,
+    });
+};
+
+type GetEpochLengthInput = Omit<SetEpochLengthInput, "length">;
+
+export const getEpochLength = async (params: GetEpochLengthInput) => {
+    const { client, governorAddress, epochManagerAddress } = params;
+
+    return await client.readContract({
+        address: epochManagerAddress,
+        account: governorAddress,
+        abi: epochManagerAbi,
+        functionName: "epochLength",
+    });
+};
+
+type GetCurrentEpochInput = {
+    client: AnvilClient<HttpTransport, Chain>;
+    epochManagerAddress: Address;
+};
+
+export const getCurrentEpoch = async (params: GetCurrentEpochInput) => {
+    const { client, epochManagerAddress } = params;
+
+    return await client.readContract({
+        address: epochManagerAddress,
+        abi: epochManagerAbi,
+        functionName: "currentEpoch",
+    });
+};

apps/agent/test/e2e/utils/prophet-e2e-scaffold/waitForEvent.ts

@@ -1,14 +1,17 @@
-import { AbiEvent, GetLogsParameters, Log } from "viem";
+import { AbiEvent, GetLogsParameters, Log, MaybeAbiEventName } from "viem";
 
 import { AnvilClient } from "./anvil.js";
 
 interface WaitForEventInput<abi extends AbiEvent, client extends AnvilClient> {
     /** Client to use for event polling */
     client: client;
     /** Event filtering */
-    filter: GetLogsParameters<abi, never, true>;
+    filter: GetLogsParameters<abi, [abi], true>;
     /** Matcher to apply to filtered events */
-    matcher: (log: Log<bigint, number, boolean, abi, true>) => boolean;
+    matcher?: (
+        log: Log<bigint, number, false, abi, true, [abi], MaybeAbiEventName<abi>>,
+    ) => boolean;
+
     /** Event polling interval in milliseconds */
     pollingIntervalMs: number;
     /** Block number to time out after the polled chain has reached the specified block */
@@ -31,12 +34,13 @@ export async function waitForEvent<abi extends AbiEvent, client extends AnvilCli
     do {
         currentBlock = (await client.getBlock({ blockTag: "latest" })).number;
 
-        const logs = await client.getLogs<abi, never, true>(filter);
+        const logs = await client.getLogs<abi, [abi], true>(filter);
+        const matchingLogs = matcher ? logs.filter(matcher) : logs;
 
-        if (logs.some(matcher)) return true;
+        if (matchingLogs && matchingLogs.length > 0) return matchingLogs[0];
 
         await new Promise((r) => setTimeout(r, pollingInterval));
     } while (currentBlock < blockTimeout);
 
-    return false;
+    throw new Error(`Event ${filter.event?.name} not found.`);
 }

apps/scripts/test/approveAccountingModules.spec.ts

@@ -45,6 +45,7 @@ describe("approveModules script", () => {
                 "Approved module: Bonded Response Module at address 0xBondedResponseModule",
             ),
         );
+
         expect(console.log).toHaveBeenCalledWith(
             expect.stringContaining(
                 "Approved module: Bond Escalation Module at address 0xBondEscalationModule",

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

@@ -283,15 +283,15 @@ const errorStrategiesEntries: [ErrorName, ErrorHandlingStrategy][] = [
         {
             shouldNotify: false,
             shouldTerminate: false,
-            shouldReenqueue: true,
+            shouldReenqueue: false,
         },
     ],
     [
         "BondEscalationModule_DisputeWindowOver",
         {
             shouldNotify: false,
             shouldTerminate: false,
-            shouldReenqueue: true,
+            shouldReenqueue: false,
         },
     ],
     [

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

@@ -33,6 +33,8 @@ export class ErrorHandler {
 
             if (strategy.shouldTerminate && context.terminateActor) {
                 context.terminateActor();
+            } else {
+                this.logger.warn(`Event handling caused an error`);
             }
         }
     }

packages/automated-dispute/src/external.ts

@@ -1,4 +1,5 @@
-export { EboProcessor, EboActorsManager, DiscordNotifier } from "./services/index.js";
+export { EboProcessor, EboActorsManager, DiscordNotifier, ProphetCodec } from "./services/index.js";
 export type { NotificationService } from "./interfaces/index.js";
 export { ProtocolProvider } from "./providers/index.js";
 export type { AccountingModules } from "./types/index.js";
+export { oracleAbi, epochManagerAbi } from "./abis/index.js";