feat(val-947): Forta alerts for SR1.5

ethereum-validators-set/e2e/agent-node-operators-registry.e2e-spec.ts

@@ -100,4 +100,15 @@ describe("agent-node-operators-registry e2e tests", () => {
     },
     TEST_TIMEOUT,
   );
+
+  it(
+    "should process tx with added simple dvt clusters",
+    async () => {
+      const findings = await runTransaction(
+        "0xc3338fc9ef0419109b90dcc318ac89bcdb235a1fe7b9960611a7d0666c1e8170",
+      );
+      expect(findings).toMatchSnapshot();
+    },
+    TEST_TIMEOUT,
+  );
 });

ethereum-validators-set/src/common/constants.ts

@@ -12,7 +12,7 @@ export const STAKING_ROUTER_ADDRESS =
 export const CURATED_NODE_OPERATORS_REGISTRY_ADDRESS =
   "0x55032650b14df07b85bf18a3a3ec8e0af2e028d5";
 export const SIMPLEDVT_NODE_OPERATORS_REGISTRY_ADDRESS =
-  "0xaE7B191A31f627b4eB1d4DaC64eaB9976995b433";
+  "0xae7b191a31f627b4eb1d4dac64eab9976995b433";
 export const DEPOSIT_SECURITY_ADDRESS =
   "0xc77f8768774e1c9244beed705c4354f2113cfc09";
 export const EL_REWARDS_VAULT_ADDRESS =

ethereum-validators-set/src/common/staking-modules/base-node-operators-registry.ts

@@ -0,0 +1,88 @@
+import { ethers } from "forta-agent";
+import NODE_OPERATORS_REGISTRY_ABI from "../../abi/NodeOperatorsRegistry.json";
+import { ethersProvider } from "../../ethers";
+import {
+  NodeOperatorFullInfo,
+  NodeOperatorSummary,
+  NodeOperatorModuleParams,
+} from "./interfaces";
+
+export abstract class BaseRegistryModule<
+  ModuleParams extends NodeOperatorModuleParams,
+> {
+  public nodeOperatorNames = new Map<number, NodeOperatorFullInfo>();
+  public readonly contract: ethers.Contract;
+  protected readonly batchSize = 20;
+
+  constructor(
+    public readonly params: ModuleParams,
+    protected readonly stakingRouter: ethers.Contract,
+  ) {
+    this.contract = new ethers.Contract(
+      this.params.moduleAddress,
+      NODE_OPERATORS_REGISTRY_ABI,
+      ethersProvider,
+    );
+  }
+
+  async initialize(currentBlock: number) {
+    return await this.updateNodeOperatorsInfo(currentBlock);
+  }
+
+  getOperatorName(nodeOperatorId: string): string {
+    return (
+      this.nodeOperatorNames.get(Number(nodeOperatorId))?.name ?? "undefined"
+    );
+  }
+
+  abstract fetchOperatorName(
+    operatorId: string,
+    block: number,
+  ): Promise<string>;
+
+  async updateNodeOperatorsInfo(block: number) {
+    const operatorsMap = await this.fetchAllNodeOperatorSummaries(block);
+
+    await Promise.all(
+      Array.from(operatorsMap.keys()).map(async (operatorId: string) => {
+        const name = await this.fetchOperatorName(operatorId, block);
+        const rewardAddress =
+          this.nodeOperatorNames.get(Number(operatorId))?.rewardAddress || "";
+        this.nodeOperatorNames.set(Number(operatorId), {
+          name,
+          rewardAddress,
+        });
+      }),
+    );
+
+    return operatorsMap;
+  }
+
+  protected async fetchAllNodeOperatorSummaries(
+    currentBlock: number,
+  ): Promise<Map<string, NodeOperatorSummary>> {
+    const operatorsMap = new Map<string, NodeOperatorSummary>();
+    const [operatorsCountBN] =
+      await this.contract.functions.getNodeOperatorsCount({
+        blockTag: currentBlock,
+      });
+    const operatorsCount = operatorsCountBN.toNumber();
+
+    for (let offset = 0; offset < operatorsCount; offset += this.batchSize) {
+      const batchSize = Math.min(this.batchSize, operatorsCount - offset);
+      const summaries = await Promise.all(
+        Array.from({ length: batchSize }, (_, i) =>
+          this.contract.functions.getNodeOperatorSummary(offset + i, {
+            blockTag: currentBlock,
+          }),
+        ),
+      );
+
+      summaries.forEach((summary, index) => {
+        operatorsMap.set(String(offset + index), summary);
+      });
+    }
+
+    return operatorsMap;
+  }
+}

ethereum-validators-set/src/common/staking-modules/csm-registry.ts

@@ -0,0 +1,8 @@
+import { BaseRegistryModule } from "./base-node-operators-registry";
+import { NodeOperatorModuleParams } from "./interfaces";
+
+export class CommunityRegistryModule extends BaseRegistryModule<NodeOperatorModuleParams> {
+  async fetchOperatorName(operatorId: string, _block: number): Promise<string> {
+    return `CSM Operator #${operatorId}`;
+  }
+}

ethereum-validators-set/src/common/staking-modules/curated-registry.ts

@@ -0,0 +1,11 @@
+import { BaseRegistryModule } from "./base-node-operators-registry";
+import { NodeOperatorModuleParams } from "./interfaces";
+
+export class CuratedRegistryModule extends BaseRegistryModule<NodeOperatorModuleParams> {
+  async fetchOperatorName(operatorId: string, block: number): Promise<string> {
+    const { name } = await this.contract.getNodeOperator(operatorId, true, {
+      blockTag: block,
+    });
+    return name;
+  }
+}

ethereum-validators-set/src/common/staking-modules/interfaces.ts

@@ -0,0 +1,22 @@
+export interface NodeOperatorModuleParams {
+  moduleId: number;
+  moduleAddress: string;
+  moduleName: string;
+  alertPrefix: string;
+}
+
+export interface NodeOperatorFullInfo {
+  name: string;
+  rewardAddress: string;
+}
+
+export interface NodeOperatorSummary {
+  targetLimitMode: number;
+  targetValidatorsCount: number;
+  stuckValidatorsCount: number;
+  refundedValidatorsCount: number;
+  stuckPenaltyEndTimestamp: number;
+  totalExitedValidators: number;
+  totalDepositedValidators: number;
+  depositableValidatorsCount: number;
+}

ethereum-validators-set/src/subagents/accounting-oracle/agent-accounting-oracle.ts

@@ -38,6 +38,7 @@ const {
   ACCOUNTING_ORACLE_ADDRESS,
   MAX_ORACLE_REPORT_MAIN_DATA_SUBMIT_DELAY,
   MAX_ORACLE_REPORT_EXTRA_DATA_SUBMIT_AFTER_MAIN_DATA_DELAY,
+  MAX_ORACLE_REPORT_EXTRA_DATA_DELAY_BETWEEN_SUBMITING,
   ACCOUNTING_ORACLE_EVENTS_OF_NOTICE,
 } = requireWithTier<typeof Constants>(
   module,
@@ -76,7 +77,10 @@ export async function initialize(
   return {};
 }
 
-async function getReportMainDataSubmits(blockFrom: number, blockTo: number) {
+export async function getReportMainDataSubmits(
+  blockFrom: number,
+  blockTo: number,
+) {
   const accountingOracle = new ethers.Contract(
     ACCOUNTING_ORACLE_ADDRESS,
     ACCOUNTING_ORACLE_ABI,
@@ -93,7 +97,10 @@ async function getReportMainDataSubmits(blockFrom: number, blockTo: number) {
   );
 }
 
-async function getReportExtraDataSubmits(blockFrom: number, blockTo: number) {
+export async function getReportExtraDataSubmits(
+  blockFrom: number,
+  blockTo: number,
+) {
   const accountingOracle = new ethers.Contract(
     ACCOUNTING_ORACLE_ADDRESS,
     ACCOUNTING_ORACLE_ABI,
@@ -118,13 +125,13 @@ export async function handleBlock(blockEvent: BlockEvent) {
   return findings;
 }
 
-async function handleMainDataReportSubmitted(
+export async function handleMainDataReportSubmitted(
   blockEvent: BlockEvent,
   findings: Finding[],
 ) {
   const now = blockEvent.block.timestamp;
   const reportMainDataSubmitDelay =
-    now - lastReportMainDataSubmitTimestamp ?? 0;
+    now - (lastReportMainDataSubmitTimestamp ?? 0);
 
   if (
     (reportMainDataSubmitDelay > MAX_ORACLE_REPORT_MAIN_DATA_SUBMIT_DELAY &&
@@ -133,8 +140,6 @@ async function handleMainDataReportSubmitted(
       MAX_ORACLE_REPORT_EXTRA_DATA_SUBMIT_AFTER_MAIN_DATA_DELAY &&
       now - lastReportExtraDataSubmitOverdueTimestamp >= TRIGGER_PERIOD)
   ) {
-    // fetch events history 1 more time to be sure that there were actually no reports during last 25 hours
-    // needed to handle situation with the missed TX with prev report
     const mainDataSubmits = await getReportMainDataSubmits(
       blockEvent.blockNumber - Math.ceil((24 * ONE_HOUR) / SECONDS_PER_SLOT),
       blockEvent.blockNumber - 1,
@@ -148,9 +153,40 @@ async function handleMainDataReportSubmitted(
         blockEvent.blockNumber - 1,
       );
       if (extraDataSubmits.length > 0) {
-        lastReportExtraDataSubmitTimestamp = (
-          await extraDataSubmits[extraDataSubmits.length - 1].getBlock()
-        ).timestamp;
+        const lastExtraDataSubmit =
+          extraDataSubmits[extraDataSubmits.length - 1];
+        const lastExtraDataSubmitBlock = await lastExtraDataSubmit.getBlock();
+        lastReportExtraDataSubmitTimestamp = lastExtraDataSubmitBlock.timestamp;
+
+        const timeSinceLastExtraSubmit =
+          now - lastReportExtraDataSubmitTimestamp;
+        const itemsProcessed =
+          parseInt(lastExtraDataSubmit.args?.itemsProcessed) ?? 0;
+        const itemsCount = parseInt(lastExtraDataSubmit.args?.itemsCount) ?? 0;
+
+        if (
+          timeSinceLastExtraSubmit >
+            MAX_ORACLE_REPORT_EXTRA_DATA_DELAY_BETWEEN_SUBMITING &&
+          itemsProcessed !== itemsCount
+        ) {
+          findings.push(
+            Finding.fromObject({
+              name: "🚨 Accounting Oracle: report EXTRA data submit incomplete",
+              description: `Time since last extra data submit: ${formatDelay(
+                timeSinceLastExtraSubmit,
+              )}. Items processed: ${itemsProcessed}/${itemsCount}.`,
+              alertId: "ACCOUNTING-ORACLE-EXTRA-DATA-INCOMPLETE",
+              severity: FindingSeverity.High,
+              type: FindingType.Degraded,
+              metadata: {
+                timeSinceLastExtraSubmit: `${timeSinceLastExtraSubmit}`,
+                itemProcessed: `${itemsProcessed}`,
+                itemCount: `${itemsCount}`,
+              },
+            }),
+          );
+          lastReportExtraDataSubmitOverdueTimestamp = now;
+        }
       }
     }
 

ethereum-validators-set/src/subagents/accounting-oracle/constants.ts

@@ -43,6 +43,7 @@ export const MAX_REPORT_SUBMIT_SKIP_BLOCKS_MEDIUM = Math.floor(
 export const MAX_ORACLE_REPORT_MAIN_DATA_SUBMIT_DELAY = ONE_DAY + 15 * 60; // 24h 15m
 export const MAX_ORACLE_REPORT_EXTRA_DATA_SUBMIT_AFTER_MAIN_DATA_DELAY =
   20 * 60; // 20m
+export const MAX_ORACLE_REPORT_EXTRA_DATA_DELAY_BETWEEN_SUBMITING = 10 * 60; // 10m
 
 export const MIN_ORACLE_BALANCE_INFO = 0.3; // 0.3 ETH