feat: add block proposal summary metric to validator monitor (#5603)

* Add block proposal summary metric to validator monitor

* Fix type errors

* Fix linter error

---------

Co-authored-by: Cayman <caymannava@gmail.com>

Author: dapplion

packages/beacon-node/src/chain/archiver/archiveBlocks.ts

@@ -1,6 +1,6 @@
 import {fromHexString} from "@chainsafe/ssz";
 import {Epoch, Slot, RootHex} from "@lodestar/types";
-import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
+import {IForkChoice} from "@lodestar/fork-choice";
 import {Logger, toHex} from "@lodestar/utils";
 import {ForkSeq, SLOTS_PER_EPOCH, MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS} from "@lodestar/params";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
@@ -18,11 +18,6 @@ const BLOB_SIDECAR_BATCH_SIZE = 32;
 
 type BlockRootSlot = {slot: Slot; root: Uint8Array};
 type CheckpointHex = {epoch: Epoch; rootHex: RootHex};
-export type FinalizedData = {
-  finalizedCanonicalCheckpoints: CheckpointHex[];
-  finalizedCanonicalBlocks: ProtoBlock[];
-  finalizedNonCanonicalBlocks: ProtoBlock[];
-};
 
 /**
  * Archives finalized blocks from active bucket to archive bucket.
@@ -41,7 +36,7 @@ export async function archiveBlocks(
   logger: Logger,
   finalizedCheckpoint: CheckpointHex,
   currentEpoch: Epoch
-): Promise<FinalizedData> {
+): Promise<void> {
   // Use fork choice to determine the blocks to archive and delete
   // getAllAncestorBlocks response includes the finalized block, so it's also moved to the cold db
   const finalizedCanonicalBlocks = forkChoice.getAllAncestorBlocks(finalizedCheckpoint.rootHex);
@@ -103,8 +98,7 @@ export async function archiveBlocks(
   }
 
   // Prunning potential checkpoint data
-  const {nonCheckpointBlocks: finalizedCanonicalNonCheckpointBlocks, checkpoints: finalizedCanonicalCheckpoints} =
-    getNonCheckpointBlocks(finalizedCanonicalBlockRoots);
+  const finalizedCanonicalNonCheckpointBlocks = getNonCheckpointBlocks(finalizedCanonicalBlockRoots);
   const nonCheckpointBlockRoots: Uint8Array[] = [...nonCanonicalBlockRoots];
   for (const block of finalizedCanonicalNonCheckpointBlocks) {
     nonCheckpointBlockRoots.push(block.root);
@@ -116,15 +110,6 @@ export async function archiveBlocks(
     totalArchived: finalizedCanonicalBlocks.length,
     finalizedEpoch: finalizedCheckpoint.epoch,
   });
-
-  return {
-    finalizedCanonicalCheckpoints: finalizedCanonicalCheckpoints.map(({root, epoch}) => ({
-      rootHex: toHex(root),
-      epoch,
-    })),
-    finalizedCanonicalBlocks,
-    finalizedNonCanonicalBlocks,
-  };
 }
 
 async function migrateBlocksFromHotToColdDb(db: IBeaconDb, blocks: BlockRootSlot[]): Promise<void> {
@@ -222,21 +207,18 @@ export function getParentRootFromSignedBlock(bytes: Uint8Array): Uint8Array {
  * @param blocks sequence of linear blocks, from child to ancestor.
  * In ProtoArray.getAllAncestorNodes child nodes are pushed first to the returned array.
  */
-export function getNonCheckpointBlocks<T extends {slot: Slot}>(
-  blocks: T[]
-): {checkpoints: (T & {epoch: Epoch})[]; nonCheckpointBlocks: T[]} {
+export function getNonCheckpointBlocks<T extends {slot: Slot}>(blocks: T[]): T[] {
   // Iterate from lowest child to highest ancestor
   // Look for the checkpoint of the lowest epoch
   // If block at `epoch * SLOTS_PER_EPOCH`, it's a checkpoint.
   // - Then for the previous epoch all blocks but the 0 are NOT checkpoints
   // - Otherwise for the previous epoch the last block is a checkpoint
 
   if (blocks.length < 1) {
-    return {checkpoints: [], nonCheckpointBlocks: []};
+    return [];
   }
 
   const nonCheckpointBlocks: T[] = [];
-  const checkpoints: (T & {epoch: Epoch})[] = [];
   // Start with Infinity to always trigger `blockEpoch < epochPtr` in the first loop
   let epochPtr = Infinity;
   // Assume worst case, since it's unknown if a future epoch will skip the first slot or not.
@@ -268,10 +250,8 @@ export function getNonCheckpointBlocks<T extends {slot: Slot}>(
 
     if (!isCheckpoint) {
       nonCheckpointBlocks.push(block);
-    } else {
-      checkpoints.push({...block, epoch: epochPtrHasFirstSlot ? blockEpoch : blockEpoch + 1});
     }
   }
 
-  return {nonCheckpointBlocks, checkpoints};
+  return nonCheckpointBlocks;
 }

packages/beacon-node/src/chain/archiver/index.ts

@@ -1,16 +1,11 @@
-import {Logger, LogLevel} from "@lodestar/utils";
-import {CheckpointWithHex, IForkChoice} from "@lodestar/fork-choice";
-import {ValidatorIndex, Slot} from "@lodestar/types";
-import {SLOTS_PER_EPOCH} from "@lodestar/params";
-
+import {Logger} from "@lodestar/utils";
+import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {IBeaconDb} from "../../db/index.js";
 import {JobItemQueue} from "../../util/queue/index.js";
 import {IBeaconChain} from "../interface.js";
 import {ChainEvent} from "../emitter.js";
-import {Metrics} from "../../metrics/metrics.js";
-import {IStateRegenerator} from "../regen/interface.js";
 import {StatesArchiver, StatesArchiverOpts} from "./archiveStates.js";
-import {archiveBlocks, FinalizedData} from "./archiveBlocks.js";
+import {archiveBlocks} from "./archiveBlocks.js";
 
 const PROCESS_FINALIZED_CHECKPOINT_QUEUE_LEN = 256;
 
@@ -48,8 +43,7 @@ export class Archiver {
     private readonly chain: IBeaconChain,
     private readonly logger: Logger,
     signal: AbortSignal,
-    opts: ArchiverOpts,
-    private readonly metrics: Metrics | null
+    opts: ArchiverOpts
   ) {
     this.statesArchiver = new StatesArchiver(chain.regen, db, logger, opts);
     this.prevFinalized = chain.forkChoice.getFinalizedCheckpoint();
@@ -95,7 +89,7 @@ export class Archiver {
     try {
       const finalizedEpoch = finalized.epoch;
       this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});
-      const finalizedData = await archiveBlocks(
+      await archiveBlocks(
         this.chain.config,
         this.db,
         this.chain.forkChoice,
@@ -104,14 +98,6 @@ export class Archiver {
         finalized,
         this.chain.clock.currentEpoch
       );
-      this.collectFinalizedProposalStats(
-        this.chain.regen,
-        this.chain.forkChoice,
-        this.chain.beaconProposerCache,
-        finalizedData,
-        finalized,
-        this.prevFinalized
-      );
       this.prevFinalized = finalized;
 
       // should be after ArchiveBlocksTask to handle restart cleanly
@@ -174,170 +160,4 @@ export class Archiver {
       this.logger.error("Error updating backfilledRanges on finalization", {epoch: finalized.epoch}, e as Error);
     }
   };
-
-  private collectFinalizedProposalStats(
-    regen: IStateRegenerator,
-    forkChoice: IForkChoice,
-    beaconProposerCache: IBeaconChain["beaconProposerCache"],
-    finalizedData: FinalizedData,
-    finalized: CheckpointWithHex,
-    lastFinalized: CheckpointWithHex
-  ): FinalizedStats {
-    const {finalizedCanonicalCheckpoints, finalizedCanonicalBlocks, finalizedNonCanonicalBlocks} = finalizedData;
-
-    // Range to consider is:
-    //   lastFinalized.epoch * SLOTS_PER_EPOCH + 1, .... finalized.epoch * SLOTS_PER_EPOCH
-    // So we need to check proposer of lastFinalized (index 1 onwards) as well as 0th index proposer
-    // of current finalized
-    const finalizedProposersCheckpoints: FinalizedData["finalizedCanonicalCheckpoints"] =
-      finalizedCanonicalCheckpoints.filter(
-        (hexCheck) => hexCheck.epoch < finalized.epoch && hexCheck.epoch > lastFinalized.epoch
-      );
-    finalizedProposersCheckpoints.push(lastFinalized);
-    finalizedProposersCheckpoints.push(finalized);
-
-    // Sort the data to in following structure to make inferences
-    const slotProposers = new Map<Slot, {canonicalVals: ValidatorIndex[]; nonCanonicalVals: ValidatorIndex[]}>();
-
-    //  1. Process canonical blocks
-    for (const block of finalizedCanonicalBlocks) {
-      // simply set to the single entry as no double proposal can be there for same slot in canonical
-      slotProposers.set(block.slot, {canonicalVals: [block.proposerIndex], nonCanonicalVals: []});
-    }
-
-    // 2. Process non canonical blocks
-    for (const block of finalizedNonCanonicalBlocks) {
-      const slotVals = slotProposers.get(block.slot) ?? {canonicalVals: [], nonCanonicalVals: []};
-      slotVals.nonCanonicalVals.push(block.proposerIndex);
-      slotProposers.set(block.slot, slotVals);
-    }
-
-    // Some simple calculatable stats for all validators
-    const finalizedCanonicalCheckpointsCount = finalizedCanonicalCheckpoints.length;
-    const expectedTotalProposalsCount = (finalized.epoch - lastFinalized.epoch) * SLOTS_PER_EPOCH;
-    const finalizedCanonicalBlocksCount = finalizedCanonicalBlocks.length;
-    const finalizedOrphanedProposalsCount = finalizedNonCanonicalBlocks.length;
-    const finalizedMissedProposalsCount = expectedTotalProposalsCount - slotProposers.size;
-
-    const allValidators: ProposalStats = {
-      total: expectedTotalProposalsCount,
-      finalized: finalizedCanonicalBlocksCount,
-      orphaned: finalizedOrphanedProposalsCount,
-      missed: finalizedMissedProposalsCount,
-    };
-
-    // Stats about the attached validators
-    const attachedProposers = beaconProposerCache
-      .getProposersSinceEpoch(finalized.epoch)
-      .map((indexString) => Number(indexString));
-    const finalizedAttachedValidatorsCount = attachedProposers.length;
-
-    // Calculate stats for attached validators, based on states in checkpointState cache
-    let finalizedFoundCheckpointsInStateCache = 0;
-
-    let expectedAttachedValidatorsProposalsCount = 0;
-    let finalizedAttachedValidatorsProposalsCount = 0;
-    let finalizedAttachedValidatorsOrphanCount = 0;
-    let finalizedAttachedValidatorsMissedCount = 0;
-
-    for (const checkpointHex of finalizedProposersCheckpoints) {
-      const checkpointState = regen.getCheckpointStateSync(checkpointHex);
-
-      // Generate stats for attached validators if we have state info
-      if (checkpointState !== null) {
-        finalizedFoundCheckpointsInStateCache++;
-
-        const epochProposers = checkpointState.epochCtx.proposers;
-        const startSlot = checkpointState.epochCtx.epoch * SLOTS_PER_EPOCH;
-
-        for (let index = 0; index < epochProposers.length; index++) {
-          const slot = startSlot + index;
-
-          // Let skip processing the slots which are out of range
-          // Range to consider is:
-          //   lastFinalized.epoch * SLOTS_PER_EPOCH + 1, .... finalized.epoch * SLOTS_PER_EPOCH
-          if (slot <= lastFinalized.epoch * SLOTS_PER_EPOCH || slot > finalized.epoch * SLOTS_PER_EPOCH) {
-            continue;
-          }
-
-          const proposer = epochProposers[index];
-
-          // If this proposer was attached to this BN for this epoch
-          if (attachedProposers.includes(proposer)) {
-            expectedAttachedValidatorsProposalsCount++;
-
-            // Get what validators made canonical/non canonical proposals for this slot
-            const {canonicalVals, nonCanonicalVals} = slotProposers.get(slot) ?? {
-              canonicalVals: [],
-              nonCanonicalVals: [],
-            };
-            let wasFinalized = false;
-
-            if (canonicalVals.includes(proposer)) {
-              finalizedAttachedValidatorsProposalsCount++;
-              wasFinalized = true;
-            }
-            const attachedProposerNonCanSlotProposals = nonCanonicalVals.filter((nonCanVal) => nonCanVal === proposer);
-            finalizedAttachedValidatorsOrphanCount += attachedProposerNonCanSlotProposals.length;
-
-            // Check is this slot proposal was missed by this attached validator
-            if (!wasFinalized && attachedProposerNonCanSlotProposals.length === 0) {
-              finalizedAttachedValidatorsMissedCount++;
-            }
-          }
-        }
-      }
-    }
-
-    const attachedValidators: ProposalStats = {
-      total: expectedAttachedValidatorsProposalsCount,
-      finalized: finalizedAttachedValidatorsProposalsCount,
-      orphaned: finalizedAttachedValidatorsOrphanCount,
-      missed: finalizedAttachedValidatorsMissedCount,
-    };
-
-    this.logger.debug("All validators finalized proposal stats", {
-      ...allValidators,
-      finalizedCanonicalCheckpointsCount,
-      finalizedFoundCheckpointsInStateCache,
-    });
-
-    // Only log to info if there is some relevant data to show
-    //  - No need to explicitly track SYNCED state since no validators attached would be there to show
-    //  - debug log if validators attached but no proposals were scheduled
-    //  - info log if proposals were scheduled (canonical) or there were orphans (non canonical)
-    if (finalizedAttachedValidatorsCount !== 0) {
-      const logLevel =
-        attachedValidators.total !== 0 || attachedValidators.orphaned !== 0 ? LogLevel.info : LogLevel.debug;
-      this.logger[logLevel]("Attached validators finalized proposal stats", {
-        ...attachedValidators,
-        validators: finalizedAttachedValidatorsCount,
-      });
-    } else {
-      this.logger.debug("No proposers attached to beacon node", {finalizedEpoch: finalized.epoch});
-    }
-
-    this.metrics?.allValidators.total.set(allValidators.total);
-    this.metrics?.allValidators.finalized.set(allValidators.finalized);
-    this.metrics?.allValidators.orphaned.set(allValidators.orphaned);
-    this.metrics?.allValidators.missed.set(allValidators.missed);
-
-    this.metrics?.attachedValidators.total.set(attachedValidators.total);
-    this.metrics?.attachedValidators.finalized.set(attachedValidators.finalized);
-    this.metrics?.attachedValidators.orphaned.set(attachedValidators.orphaned);
-    this.metrics?.attachedValidators.missed.set(attachedValidators.missed);
-
-    this.metrics?.finalizedCanonicalCheckpointsCount.set(finalizedCanonicalCheckpointsCount);
-    this.metrics?.finalizedFoundCheckpointsInStateCache.set(finalizedFoundCheckpointsInStateCache);
-    this.metrics?.finalizedAttachedValidatorsCount.set(finalizedAttachedValidatorsCount);
-
-    // Return stats data for the ease of unit testing
-    return {
-      allValidators,
-      attachedValidators,
-      finalizedCanonicalCheckpointsCount,
-      finalizedFoundCheckpointsInStateCache,
-      finalizedAttachedValidatorsCount,
-    };
-  }
 }

packages/beacon-node/src/chain/beaconProposerCache.ts

@@ -8,23 +8,16 @@ const PROPOSER_PRESERVE_EPOCHS = 2;
 export type ProposerPreparationData = routes.validator.ProposerPreparationData;
 
 export class BeaconProposerCache {
-  private readonly feeRecipientByValidatorIndex: MapDef<
-    string,
-    {epoch: Epoch; feeRecipient: string; sinceEpoch: Epoch}
-  >;
+  private readonly feeRecipientByValidatorIndex: MapDef<string, {epoch: Epoch; feeRecipient: string}>;
   constructor(opts: {suggestedFeeRecipient: string}, private readonly metrics?: Metrics | null) {
-    this.feeRecipientByValidatorIndex = new MapDef<string, {epoch: Epoch; feeRecipient: string; sinceEpoch: Epoch}>(
-      () => ({
-        epoch: 0,
-        feeRecipient: opts.suggestedFeeRecipient,
-        sinceEpoch: 0,
-      })
-    );
+    this.feeRecipientByValidatorIndex = new MapDef(() => ({
+      epoch: 0,
+      feeRecipient: opts.suggestedFeeRecipient,
+    }));
   }
 
   add(epoch: Epoch, {validatorIndex, feeRecipient}: ProposerPreparationData): void {
-    const sinceEpoch = this.feeRecipientByValidatorIndex.get(validatorIndex)?.sinceEpoch ?? epoch;
-    this.feeRecipientByValidatorIndex.set(validatorIndex, {epoch, feeRecipient, sinceEpoch});
+    this.feeRecipientByValidatorIndex.set(validatorIndex, {epoch, feeRecipient});
   }
 
   prune(epoch: Epoch): void {
@@ -44,14 +37,4 @@ export class BeaconProposerCache {
   get(proposerIndex: number | string): string | undefined {
     return this.feeRecipientByValidatorIndex.get(`${proposerIndex}`)?.feeRecipient;
   }
-
-  getProposersSinceEpoch(epoch: Epoch): ProposerPreparationData["validatorIndex"][] {
-    const proposers = [];
-    for (const [validatorIndex, feeRecipientEntry] of this.feeRecipientByValidatorIndex.entries()) {
-      if (feeRecipientEntry.sinceEpoch <= epoch) {
-        proposers.push(validatorIndex);
-      }
-    }
-    return proposers;
-  }
 }

packages/beacon-node/src/chain/chain.ts

@@ -275,7 +275,7 @@ export class BeaconChain implements IBeaconChain {
     this.emitter = emitter;
     this.lightClientServer = lightClientServer;
 
-    this.archiver = new Archiver(db, this, logger, signal, opts, metrics);
+    this.archiver = new Archiver(db, this, logger, signal, opts);
     // always run PrepareNextSlotScheduler except for fork_choice spec tests
     if (!opts?.disablePrepareNextSlot) {
       new PrepareNextSlotScheduler(this, this.config, metrics, this.logger, signal);

packages/beacon-node/src/chain/forkChoice/index.ts

@@ -65,7 +65,6 @@ export function initializeForkChoice(
     ProtoArray.initialize(
       {
         slot: blockHeader.slot,
-        proposerIndex: blockHeader.proposerIndex,
         parentRoot: toHexString(blockHeader.parentRoot),
         stateRoot: toHexString(blockHeader.stateRoot),
         blockRoot: toHexString(checkpoint.root),