Feat/relayer tests

relayer-cli/package.json

@@ -20,7 +20,7 @@
     "dotenv": "^16.4.5",
     "pm2": "^5.2.2",
     "typescript": "^4.9.5",
-    "web3": "^4.16.0",
+    "web3": "^1.10.4",
     "web3-batched-send": "^1.0.3"
   },
   "devDependencies": {

relayer-cli/src/devnetRelayExample.ts

@@ -1,26 +1,29 @@
+import { EventEmitter } from "events";
 import { relayAllFrom } from "./utils/relay";
 import { initialize, ShutdownManager, updateStateFile, setupExitHandlers, delay } from "./utils/relayerHelpers";
+import { BotEvents } from "utils/botEvents";
 
-export async function start(shutdownManager: ShutdownManager = new ShutdownManager()) {
+export async function start(shutdownManager: ShutdownManager = new ShutdownManager(), emitter: EventEmitter) {
   const chainId = parseInt(process.env.VEAOUTBOX_CHAIN_ID);
   const epochPeriod = 1800; // 30 min
   const network = "devnet";
-  await setupExitHandlers(chainId, shutdownManager, network);
+  await setupExitHandlers(chainId, shutdownManager, network, emitter);
   while (!shutdownManager.getIsShuttingDown()) {
-    let nonce = await initialize(chainId, network);
+    let nonce = await initialize(chainId, network, emitter);
     // This is libghtbulb switch address in arbitrum sepolia
     const sender = process.env.DEVNET_SENDER;
     nonce = await relayAllFrom(chainId, nonce, sender);
-    if (nonce != null) await updateStateFile(chainId, Math.floor(Date.now() / 1000), nonce, network);
+    if (nonce != null) await updateStateFile(chainId, Math.floor(Date.now() / 1000), nonce, network, emitter);
 
     const currentTS = Math.floor(Date.now() / 1000);
     const delayAmount = (epochPeriod - (currentTS % epochPeriod)) * 1000 + 100 * 1000;
-    console.log("waiting for the next epoch. . .", Math.floor(delayAmount / 1000), "seconds");
+    emitter.emit(BotEvents.WAITING, delayAmount);
     await delay(delayAmount);
   }
 }
 
 if (require.main === module) {
+  const emitter = new EventEmitter();
   const shutdownManager = new ShutdownManager(false);
-  start(shutdownManager);
+  start(shutdownManager, emitter);
 }

relayer-cli/src/testnetRelayer.ts

@@ -1,28 +1,64 @@
 require("dotenv").config();
-import { relayBatch } from "utils/relay";
-import { initialize, updateStateFile, delay, setupExitHandlers, ShutdownManager } from "utils/relayerHelpers";
+import { EventEmitter } from "node:events";
+import { relayBatch, RelayBatchDeps } from "utils/relay";
+import {
+  initialize as initializeNonce,
+  updateStateFile,
+  delay,
+  setupExitHandlers,
+  ShutdownManager,
+} from "utils/relayerHelpers";
 import { getEpochPeriod } from "consts/bridgeRoutes";
+import { initialize as initializeEmitter } from "utils/logger";
+import { BotEvents } from "utils/botEvents";
 
-export async function start(shutdownManager: ShutdownManager = new ShutdownManager()) {
-  const network = "testnet";
-  const chainId = parseInt(process.env.VEAOUTBOX_CHAIN_ID);
+interface RelayerConfig {
+  chainId: number;
+  network: string;
+  shutdownManager: ShutdownManager;
+  emitter: EventEmitter;
+}
+
+/**
+ * Start the relayer
+ * @param chainId The chain id of the relayer
+ * @param network The network of the relayer
+ * @param shutdownManager The shutdown manager
+ * @param emitter The event emitter
+ */
+export async function start({ chainId, network, shutdownManager, emitter }: RelayerConfig) {
+  initializeEmitter(emitter);
+  emitter.emit(BotEvents.STARTED, chainId, network);
   const epochPeriod = getEpochPeriod(chainId);
-  const batchSize = 10; // 10 messages per batch
+  const maxBatchSize = 10; // 10 messages per batch
 
-  await setupExitHandlers(chainId, shutdownManager, network);
+  await setupExitHandlers(chainId, shutdownManager, network, emitter);
 
   while (!shutdownManager.getIsShuttingDown()) {
-    let nonce = await initialize(chainId, network);
-    nonce = await relayBatch(chainId, nonce, batchSize);
-    if (nonce != null) await updateStateFile(chainId, Math.floor(Date.now() / 1000), nonce, network);
+    let nonce = await initializeNonce(chainId, network, emitter);
+    const relayBatchDeps: RelayBatchDeps = {
+      chainId,
+      nonce,
+      maxBatchSize,
+    };
+    nonce = await relayBatch(relayBatchDeps);
+    if (nonce != null) await updateStateFile(chainId, Math.floor(Date.now() / 1000), nonce, network, emitter);
     const currentTS = Math.floor(Date.now() / 1000);
     const delayAmount = (epochPeriod - (currentTS % epochPeriod)) * 1000 + 100 * 1000;
-    console.log("waiting for the next epoch. . .", Math.floor(delayAmount / 1000), "seconds");
+    emitter.emit(BotEvents.WAITING, delayAmount);
     await delay(delayAmount);
   }
 }
 
 if (require.main === module) {
+  const emitter = new EventEmitter();
   const shutdownManager = new ShutdownManager(false);
-  start(shutdownManager);
+  const testnetRelayerConfig: RelayerConfig = {
+    shutdownManager,
+    emitter,
+    chainId: Number(process.env.VEAOUTBOX_CHAIN_ID),
+    network: "testnet",
+  };
+
+  start(testnetRelayerConfig);
 }

relayer-cli/src/utils/botEvents.ts

@@ -0,0 +1,15 @@
+export enum BotEvents {
+  // Bridger state
+  STARTED = "started",
+  WAITING = "waiting",
+  EXIT = "exit",
+
+  // Bot health
+  EXCEPTION = "exception",
+  PROMISE_REJECTION = "promise_rejection",
+
+  // Lock file
+  LOCK_CLAIMED = "lock_claimed",
+  LOCK_DIRECTORY = "lock_directory",
+  LOCK_RELEASED = "lock_released",
+}

relayer-cli/src/utils/ethers.ts

@@ -6,7 +6,7 @@ import {
   VeaInboxArbToGnosis__factory,
   VeaOutboxArbToGnosis__factory,
 } from "@kleros/vea-contracts/typechain-types";
-import { getBridgeConfig } from "consts/bridgeRoutes";
+import { getBridgeConfig } from "../consts/bridgeRoutes";
 
 function getWallet(privateKey: string, web3ProviderURL: string): Wallet {
   return new Wallet(privateKey, new JsonRpcProvider(web3ProviderURL));

relayer-cli/src/utils/logger.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from "node:events";
+import { BotEvents } from "./botEvents";
+
+/**
+ * Listens to relevant events of an EventEmitter instance and issues log lines
+ *
+ * @param emitter - The event emitter instance that issues the relevant events
+ *
+ * @example
+ *
+ * const emitter = new EventEmitter();
+ * initialize(emitter);
+ */
+
+export const initialize = (emitter: EventEmitter) => {
+  return configurableInitialize(emitter);
+};
+
+export const configurableInitialize = (emitter: EventEmitter) => {
+  // Relayer state logs
+  emitter.on(BotEvents.STARTED, (chainId, network) => {
+    console.log(`Relayer started for ${chainId} on ${network}`);
+  });
+  emitter.on(BotEvents.WAITING, (delayAmount) => {
+    console.log(`Waiting for next epoch: ${delayAmount} ms`);
+  });
+  emitter.on(BotEvents.EXIT, () => {
+    console.log("Exiting");
+  });
+
+  // Bot health logs
+  emitter.on(BotEvents.EXCEPTION, (err) => {
+    console.error("Uncaught Exception occurred", err);
+  });
+  emitter.on(BotEvents.PROMISE_REJECTION, (reason, promise) => {
+    console.error("Unhandled promise rejection:", reason, "at", promise);
+  });
+
+  // Lock file logs
+  emitter.on(BotEvents.LOCK_CLAIMED, () => {
+    console.log("Lock claimed");
+  });
+  emitter.on(BotEvents.LOCK_DIRECTORY, (pwd) => {
+    console.log(`Lock file directory: ${pwd}`);
+  });
+  emitter.on(BotEvents.LOCK_RELEASED, () => {
+    console.log("Lock released");
+  });
+};

relayer-cli/src/utils/proof.test.ts

@@ -0,0 +1,20 @@
+import { getProofIndices } from "./proof";
+
+describe("proof", () => {
+  describe("getProofIndices", () => {
+    it("should return an empty array", () => {
+      const result = getProofIndices(7, 7);
+      expect(result).toEqual([]);
+    });
+    it("should return the proof indices", () => {
+      const expectedProofIndices = ["3", "0,1", "4,6"];
+      const result = getProofIndices(2, 7);
+      expect(result).toEqual(expectedProofIndices);
+    });
+    it("should return the proof indices(for a large count", () => {
+      const expectedProofIndices = ["6", "4,5", "0,3", "8,14"];
+      const result = getProofIndices(7, 15);
+      expect(result).toEqual(expectedProofIndices);
+    });
+  });
+});

relayer-cli/src/utils/proof.ts

@@ -1,11 +1,17 @@
 import request from "graphql-request";
 import { getInboxSubgraph } from "../consts/bridgeRoutes";
 
-const getMessageDataToRelay = async (chainid: number, nonce: number) => {
+/**
+ * Get the message data to relay from the subgraph
+ * @param chainId The chain id of the veaOutbox chain
+ * @param nonce The nonce of the message
+ * @returns The message id and data to relay
+ */
+const getMessageDataToRelay = async (chainId: number, nonce: number, requestGraph: typeof request = request) => {
   try {
-    const subgraph = getInboxSubgraph(chainid);
+    const subgraph = getInboxSubgraph(chainId);
 
-    const result = await request(
+    const result = await requestGraph(
       `https://api.studio.thegraph.com/query/${subgraph}`,
       `{
                 messageSents(first: 5, where: {nonce: ${nonce}}) {
@@ -24,9 +30,22 @@ const getMessageDataToRelay = async (chainid: number, nonce: number) => {
   }
 };
 
-const getProofAtCount = async (chainid: number, nonce: number, count: number): Promise<string[]> => {
-  const proofIndices = getProofIndices(nonce, count);
-
+/**
+ * Get the proof of the message at a given count
+ * @param chainId The chain id of the veaOutbox chain
+ * @param nonce The nonce of the message
+ * @param count The current veaOutbox count
+ * @returns The proof of the message
+ */
+const getProofAtCount = async (
+  chainId: number,
+  nonce: number,
+  count: number,
+  requestGraph: typeof request = request,
+  calculateProofIndices: typeof getProofIndices = getProofIndices,
+  fetchInboxSubgraph: typeof getInboxSubgraph = getInboxSubgraph
+): Promise<string[]> => {
+  const proofIndices = calculateProofIndices(nonce, count);
   if (proofIndices.length == 0) return [];
 
   let query = "{";
@@ -38,23 +57,27 @@ const getProofAtCount = async (chainid: number, nonce: number, count: number): P
   query += "}";
 
   try {
-    const subgraph = getInboxSubgraph(chainid);
+    const subgraph = fetchInboxSubgraph(chainId);
 
-    const result = await request(`https://api.studio.thegraph.com/query/${subgraph}`, query);
+    const result = await requestGraph(`https://api.studio.thegraph.com/query/${subgraph}`, query);
 
     const proof = [];
-
     for (let i = 0; i < proofIndices.length; i++) {
       proof.push(result[`layer${i}`][0].hash);
     }
-
     return proof;
   } catch (e) {
     console.log(e);
     return [];
   }
 };
 
+/**
+ * Get the proof indices of the message
+ * @param nonce The nonce of the message
+ * @param count The current veaOutbox count
+ * @returns The proof indices of the message
+ */
 const getProofIndices = (nonce: number, count: number) => {
   let proof = [];
   if (nonce >= count) return proof;
@@ -76,4 +99,4 @@ const getProofIndices = (nonce: number, count: number) => {
   return proof;
 };
 
-export { getProofAtCount, getMessageDataToRelay };
+export { getProofAtCount, getMessageDataToRelay, getProofIndices };