@lodestar/beacon-node 1.40.0-dev.3be9500fa9 → 1.40.0-dev.63c5c3e7f7

package/src/chain/validatorMonitor.ts

@@ -24,7 +24,7 @@ import {
   altair,
   deneb,
 } from "@lodestar/types";
-import {LogData, LogHandler, LogLevel, Logger, MapDef, MapDefMax, toRootHex} from "@lodestar/utils";
+import {LogData, LogHandler, LogLevel, Logger, MapDef, MapDefMax, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {GENESIS_SLOT} from "../constants/constants.js";
 import {RegistryMetricCreator} from "../metrics/index.js";
 
@@ -39,7 +39,8 @@ const MAX_CACHED_DISTINCT_TARGETS = 4;
 const LATE_ATTESTATION_SUBMISSION_BPS = 5000;
 const LATE_BLOCK_SUBMISSION_BPS = 2500;
 
-const RETAIN_REGISTERED_VALIDATORS_MS = 1 * 3600 * 1000; // 1 hour
+/** Number of epochs to retain registered validators after their last registration */
+const RETAIN_REGISTERED_VALIDATORS_EPOCHS = 2;
 
 type Seconds = number;
 export enum OpSource {
@@ -97,6 +98,8 @@ export type ValidatorMonitor = {
   ): void;
   onceEveryEndOfEpoch(state: CachedBeaconStateAllForks): void;
   scrapeMetrics(slotClock: Slot): void;
+  /** Returns the list of validator indices currently being monitored */
+  getMonitoredValidatorIndices(): ValidatorIndex[];
 };
 
 export type ValidatorMonitorOpts = {
@@ -284,6 +287,9 @@ export function createValidatorMonitor(
     logger[logLevel](message, context);
   };
 
+  // Calculate retain time dynamically based on slot duration (2 epochs)
+  const retainRegisteredValidatorsMs = SLOTS_PER_EPOCH * config.SLOT_DURATION_MS * RETAIN_REGISTERED_VALIDATORS_EPOCHS;
+
   /** The validators that require additional monitoring. */
   const validators = new MapDef<ValidatorIndex, MonitoredValidator>(() => ({
     summaries: new Map<Epoch, EpochSummary>(),
@@ -306,11 +312,19 @@ export function createValidatorMonitor(
 
   let lastRegisteredStatusEpoch = -1;
 
+  // Track validator additions/removals per epoch for logging
+  const addedValidatorsInEpoch: Set<ValidatorIndex> = new Set();
+  const removedValidatorsInEpoch: Set<ValidatorIndex> = new Set();
+
   const validatorMonitorMetrics = metricsRegister ? createValidatorMonitorMetrics(metricsRegister) : null;
 
   const validatorMonitor: ValidatorMonitor = {
     registerLocalValidator(index) {
+      const isNewValidator = !validators.has(index);
       validators.getOrDefault(index).lastRegisteredTimeMs = Date.now();
+      if (isNewValidator) {
+        addedValidatorsInEpoch.add(index);
+      }
     },
 
     registerLocalValidatorInSyncCommittee(index, untilEpoch) {
@@ -673,11 +687,29 @@ export function createValidatorMonitor(
 
       // Prune validators not seen in a while
       for (const [index, validator] of validators.entries()) {
-        if (Date.now() - validator.lastRegisteredTimeMs > RETAIN_REGISTERED_VALIDATORS_MS) {
+        if (Date.now() - validator.lastRegisteredTimeMs > retainRegisteredValidatorsMs) {
           validators.delete(index);
+          removedValidatorsInEpoch.add(index);
         }
       }
 
+      // Log validator monitor status every epoch
+      const allIndices = Array.from(validators.keys()).sort((a, b) => a - b);
+      const addedIndices = Array.from(addedValidatorsInEpoch).sort((a, b) => a - b);
+      const removedIndices = Array.from(removedValidatorsInEpoch).sort((a, b) => a - b);
+
+      log("Validator monitor status", {
+        epoch: computeEpochAtSlot(headState.slot),
+        added: addedIndices.length > 0 ? prettyPrintIndices(addedIndices) : "none",
+        removed: removedIndices.length > 0 ? prettyPrintIndices(removedIndices) : "none",
+        total: validators.size,
+        indices: prettyPrintIndices(allIndices),
+      });
+
+      // Clear tracking sets for next epoch
+      addedValidatorsInEpoch.clear();
+      removedValidatorsInEpoch.clear();
+
       // Compute summaries of previous epoch attestation performance
       const prevEpoch = computeEpochAtSlot(headState.slot) - 1;
 
@@ -736,6 +768,13 @@ export function createValidatorMonitor(
     scrapeMetrics(slotClock) {
       validatorMonitorMetrics?.validatorsConnected.set(validators.size);
 
+      // Update static metric with connected validator indices
+      if (validatorMonitorMetrics?.validatorsConnectedIndices) {
+        validatorMonitorMetrics.validatorsConnectedIndices.reset();
+        const allIndices = Array.from(validators.keys()).sort((a, b) => a - b);
+        validatorMonitorMetrics.validatorsConnectedIndices.set({indices: prettyPrintIndices(allIndices)}, 1);
+      }
+
       const epoch = computeEpochAtSlot(slotClock);
       const slotInEpoch = slotClock % SLOTS_PER_EPOCH;
 
@@ -815,6 +854,10 @@ export function createValidatorMonitor(
       validatorMonitorMetrics?.prevEpochSyncCommitteeHits.set(prevEpochSyncCommitteeHits);
       validatorMonitorMetrics?.prevEpochSyncCommitteeMisses.set(prevEpochSyncCommitteeMisses);
     },
+
+    getMonitoredValidatorIndices() {
+      return Array.from(validators.keys()).sort((a, b) => a - b);
+    },
   };
 
   // Register a single collect() function to run all validatorMonitor metrics
@@ -1098,6 +1141,12 @@ function createValidatorMonitorMetrics(register: RegistryMetricCreator) {
       help: "Count of validators that are specifically monitored by this beacon node",
     }),
 
+    validatorsConnectedIndices: register.gauge<{indices: string}>({
+      name: "validator_monitor_indices",
+      help: "Static metric with connected validator indices as label, value is always 1",
+      labelNames: ["indices"],
+    }),
+
     validatorsInSyncCommittee: register.gauge({
       name: "validator_monitor_validators_in_sync_committee",
       help: "Count of validators monitored by this beacon node that are part of sync committee",

package/src/metrics/metrics/lodestar.ts

@@ -212,6 +212,31 @@ export function createLodestarMetrics(
       }),
     },
 
+    unfinalizedBlockWritesQueue: {
+      length: register.gauge({
+        name: "lodestar_unfinalized_block_writes_queue_length",
+        help: "Count of total unfinalized block writes queue length",
+      }),
+      droppedJobs: register.gauge({
+        name: "lodestar_unfinalized_block_writes_queue_dropped_jobs_total",
+        help: "Count of total unfinalized block writes queue dropped jobs",
+      }),
+      jobTime: register.histogram({
+        name: "lodestar_unfinalized_block_writes_queue_job_time_seconds",
+        help: "Time to process unfinalized block writes queue job in seconds",
+        buckets: [0.01, 0.1, 1, 4, 12],
+      }),
+      jobWaitTime: register.histogram({
+        name: "lodestar_unfinalized_block_writes_queue_job_wait_time_seconds",
+        help: "Time from job added to the unfinalized block writes queue to starting in seconds",
+        buckets: [0.01, 0.1, 1, 4, 12],
+      }),
+      concurrency: register.gauge({
+        name: "lodestar_unfinalized_block_writes_queue_concurrency",
+        help: "Current concurrency of unfinalized block writes queue",
+      }),
+    },
+
     engineHttpProcessorQueue: {
       length: register.gauge({
         name: "lodestar_engine_http_processor_queue_length",

package/src/network/processor/gossipHandlers.ts

@@ -436,14 +436,11 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         blsVerifyOnMainThread: true,
         // to track block process steps
         seenTimestampSec,
-        // gossip block is validated, we want to process it asap
-        eagerPersistBlock: true,
       })
       .then(() => {
         // Returns the delay between the start of `block.slot` and `current time`
         const delaySec = chain.clock.secFromSlot(slot);
         metrics?.gossipBlock.elapsedTimeTillProcessed.observe(delaySec);
-        chain.seenBlockInputCache.prune(blockInput.blockRootHex);
       })
       .catch((e) => {
         // Adjust verbosity based on error type

package/src/network/reqresp/handlers/beaconBlocksByRange.ts

@@ -4,7 +4,6 @@ import {GENESIS_SLOT, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {deneb, phase0} from "@lodestar/types";
-import {fromHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
 import {prettyPrintPeerId} from "../../util.ts";
@@ -22,7 +21,6 @@ export async function* onBeaconBlocksByRange(
   const endSlot = startSlot + count;
 
   const finalized = db.blockArchive;
-  const unfinalized = db.block;
   // in the case of initializing from a non-finalized state, we don't have the finalized block so this api does not work
   // chain.forkChoice.getFinalizeBlock().slot
   const finalizedSlot = chain.forkChoice.getFinalizedCheckpointSlot();
@@ -65,7 +63,7 @@ export async function* onBeaconBlocksByRange(
         // re-org there's no need to abort the request
         // Spec: https://github.com/ethereum/consensus-specs/blob/a1e46d1ae47dd9d097725801575b46907c12a1f8/specs/eip4844/p2p-interface.md#blobssidecarsbyrange-v1
 
-        const blockBytes = await unfinalized.getBinary(fromHex(block.blockRoot));
+        const blockBytes = await chain.getSerializedBlockByRoot(block.blockRoot);
         if (!blockBytes) {
           throw new ResponseError(
             RespStatus.SERVER_ERROR,
@@ -74,7 +72,7 @@ export async function* onBeaconBlocksByRange(
         }
 
         yield {
-          data: blockBytes,
+          data: blockBytes.block,
           boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(block.slot)),
         };
       }

package/src/network/reqresp/handlers/beaconBlocksByRoot.ts

@@ -1,48 +1,21 @@
 import {ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {Slot} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {getSlotFromSignedBeaconBlockSerialized} from "../../../util/sszBytes.js";
 import {BeaconBlocksByRootRequest} from "../../../util/types.js";
 
 export async function* onBeaconBlocksByRoot(
   requestBody: BeaconBlocksByRootRequest,
-  chain: IBeaconChain,
-  db: IBeaconDb
+  chain: IBeaconChain
 ): AsyncIterable<ResponseOutgoing> {
   for (const blockRoot of requestBody) {
     const root = blockRoot;
-    const summary = chain.forkChoice.getBlock(root);
-    let blockBytes: Uint8Array | null = null;
-
-    // finalized block has summary in forkchoice but it stays in blockArchive db
-    if (summary) {
-      blockBytes = await db.block.getBinary(root);
-    }
-
-    let slot: Slot | undefined = undefined;
-    if (!blockBytes) {
-      const blockEntry = await db.blockArchive.getBinaryEntryByRoot(root);
-      if (blockEntry) {
-        slot = blockEntry.key;
-        blockBytes = blockEntry.value;
-      }
-    }
-
-    if (blockBytes) {
-      if (slot === undefined) {
-        const slotFromBytes = getSlotFromSignedBeaconBlockSerialized(blockBytes);
-        if (slotFromBytes === null) {
-          throw Error(`Invalid block bytes for block root ${toRootHex(root)}`);
-        }
-        slot = slotFromBytes;
-      }
+    const block = await chain.getSerializedBlockByRoot(toRootHex(root));
 
+    if (block) {
       yield {
-        data: blockBytes,
-        boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(slot)),
+        data: block.block,
+        boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(block.slot)),
       };
     }
   }

package/src/network/reqresp/handlers/blobSidecarsByRoot.ts

@@ -2,16 +2,13 @@ import {BLOB_SIDECAR_FIXED_SIZE} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {RootHex} from "@lodestar/types";
-import {fromHex, toRootHex} from "@lodestar/utils";
+import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {BLOB_SIDECARS_IN_WRAPPER_INDEX} from "../../../db/repositories/blobSidecars.js";
 import {BlobSidecarsByRootRequest} from "../../../util/types.js";
 
 export async function* onBlobSidecarsByRoot(
   requestBody: BlobSidecarsByRootRequest,
-  chain: IBeaconChain,
-  db: IBeaconDb
+  chain: IBeaconChain
 ): AsyncIterable<ResponseOutgoing> {
   const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
 
@@ -34,14 +31,13 @@ export async function* onBlobSidecarsByRoot(
 
     // Check if we need to load sidecars for a new block root
     if (lastFetchedSideCars === null || lastFetchedSideCars.blockRoot !== blockRootHex) {
-      const blobSideCarsBytesWrapped = await db.blobSidecars.getBinary(fromHex(block.blockRoot));
-      if (!blobSideCarsBytesWrapped) {
+      const blobSidecarsBytes = await chain.getSerializedBlobSidecars(block.slot, blockRootHex);
+      if (!blobSidecarsBytes) {
         // Handle the same to onBeaconBlocksByRange
         throw new ResponseError(RespStatus.SERVER_ERROR, `No item for root ${block.blockRoot} slot ${block.slot}`);
       }
-      const blobSideCarsBytes = blobSideCarsBytesWrapped.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
 
-      lastFetchedSideCars = {blockRoot: blockRootHex, bytes: blobSideCarsBytes};
+      lastFetchedSideCars = {blockRoot: blockRootHex, bytes: blobSidecarsBytes};
     }
 
     const blobSidecarBytes = lastFetchedSideCars.bytes.slice(

package/src/network/reqresp/handlers/dataColumnSidecarsByRange.ts

@@ -38,7 +38,6 @@ export async function* onDataColumnSidecarsByRange(
   }
 
   const finalized = db.dataColumnSidecarArchive;
-  const unfinalized = db.dataColumnSidecar;
   const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
 
   // Finalized range of columns
@@ -92,7 +91,11 @@ export async function* onDataColumnSidecarsByRange(
         // at the time of the start of the request. Spec is clear the chain of columns must be consistent, but on
         // re-org there's no need to abort the request
         // Spec: https://github.com/ethereum/consensus-specs/blob/ad36024441cf910d428d03f87f331fbbd2b3e5f1/specs/fulu/p2p-interface.md#L425-L429
-        const dataColumnSidecars = await unfinalized.getManyBinary(fromHex(block.blockRoot), availableColumns);
+        const dataColumnSidecars = await chain.getSerializedDataColumnSidecars(
+          block.slot,
+          block.blockRoot,
+          availableColumns
+        );
 
         const unavailableColumnIndices: ColumnIndex[] = [];
         for (let i = 0; i < dataColumnSidecars.length; i++) {

package/src/network/reqresp/handlers/dataColumnSidecarsByRoot.ts

@@ -61,11 +61,7 @@ export async function* onDataColumnSidecarsByRoot(
       continue;
     }
 
-    const dataColumns = block
-      ? // Non-finalized sidecars are stored by block root
-        await db.dataColumnSidecar.getManyBinary(blockRoot, availableColumns)
-      : // Finalized sidecars are archived and stored by slot
-        await db.dataColumnSidecarArchive.getManyBinary(slot, availableColumns);
+    const dataColumns = await chain.getSerializedDataColumnSidecars(slot, blockRootHex, availableColumns);
 
     const unavailableColumnIndices: ColumnIndex[] = [];
     for (let i = 0; i < dataColumns.length; i++) {

package/src/network/reqresp/handlers/index.ts

@@ -42,12 +42,12 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
     [ReqRespMethod.BeaconBlocksByRoot]: (req) => {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       const body = BeaconBlocksByRootRequestType(fork, chain.config).deserialize(req.data);
-      return onBeaconBlocksByRoot(body, chain, db);
+      return onBeaconBlocksByRoot(body, chain);
     },
     [ReqRespMethod.BlobSidecarsByRoot]: (req) => {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       const body = BlobSidecarsByRootRequestType(fork, chain.config).deserialize(req.data);
-      return onBlobSidecarsByRoot(body, chain, db);
+      return onBlobSidecarsByRoot(body, chain);
     },
     [ReqRespMethod.BlobSidecarsByRange]: (req) => {
       const body = ssz.deneb.BlobSidecarsByRangeRequest.deserialize(req.data);

package/src/sync/range/chain.ts

@@ -585,7 +585,6 @@ export class SyncChain {
 
     if (!res.err) {
       batch.processingSuccess();
-      this.pruneBlockInputs(batch.getBlocks());
 
       // If the processed batch is not empty, validate previous AwaitingValidation blocks.
       if (blocks.length > 0) {

package/src/sync/range/range.ts

@@ -188,9 +188,6 @@ export class RangeSync extends (EventEmitter as {new (): RangeSyncEmitter}) {
       // when this runs, syncing is the most important thing and gossip is not likely to run
       // so we can utilize worker threads to verify signatures
       blsVerifyOnMainThread: false,
-      // we want to be safe to only persist blocks after verifying it to avoid any attacks that may cause our DB
-      // to grow too much
-      eagerPersistBlock: false,
     };
 
     if (this.opts?.disableProcessAsChainSegment) {

package/src/sync/unknownBlock.ts

@@ -423,8 +423,6 @@ export class BlockInputSync {
         // see https://github.com/ChainSafe/lodestar/issues/5650
         ignoreIfFinalized: true,
         blsVerifyOnMainThread: true,
-        // block is validated with correct root, we want to process it as soon as possible
-        eagerPersistBlock: true,
       })
     );
 
@@ -434,7 +432,6 @@ export class BlockInputSync {
     if (!res.err) {
       // no need to update status to "processed", delete anyway
       this.pendingBlocks.delete(pendingBlock.blockInput.blockRootHex);
-      this.chain.seenBlockInputCache.prune(pendingBlock.blockInput.blockRootHex);
 
       // Send child blocks to the processor
       for (const descendantBlock of getDescendantBlocks(pendingBlock.blockInput.blockRootHex, this.pendingBlocks)) {