@lodestar/beacon-node 1.36.0-dev.f657221d88 → 1.36.0-dev.fe5f423da3

package/src/chain/archiveStore/archiveStore.ts

@@ -25,6 +25,16 @@ type ArchiveStoreModules = {
 
 type ArchiveStoreInitOpts = ArchiveStoreOpts & {dbName: string; anchorState: {finalizedCheckpoint: Checkpoint}};
 
+export enum ArchiveStoreTask {
+  ArchiveBlocks = "archive_blocks",
+  PruneHistory = "prune_history",
+  OnFinalizedCheckpoint = "on_finalized_checkpoint",
+  MaybeArchiveState = "maybe_archive_state",
+  RegenPruneOnFinalized = "regen_prune_on_finalized",
+  ForkchoicePrune = "forkchoice_prune",
+  UpdateBackfillRange = "update_backfill_range",
+}
+
 /**
  * Used for running tasks that depends on some events or are executed
  * periodically.
@@ -176,6 +186,8 @@ export class ArchiveStore {
     try {
       const finalizedEpoch = finalized.epoch;
       this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});
+
+      let timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await archiveBlocks(
         this.chain.config,
         this.db,
@@ -188,7 +200,10 @@ export class ArchiveStore {
         this.chain.opts.persistOrphanedBlocks,
         this.chain.opts.persistOrphanedBlocksDir
       );
+      timer?.({source: ArchiveStoreTask.ArchiveBlocks});
+
       if (this.opts.pruneHistory) {
+        timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
         await pruneHistory(
           this.chain.config,
           this.db,
@@ -197,18 +212,30 @@ export class ArchiveStore {
           finalizedEpoch,
           this.chain.clock.currentEpoch
         );
+        timer?.({source: ArchiveStoreTask.PruneHistory});
       }
 
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await this.statesArchiverStrategy.onFinalizedCheckpoint(finalized, this.metrics);
+      timer?.({source: ArchiveStoreTask.OnFinalizedCheckpoint});
 
       // should be after ArchiveBlocksTask to handle restart cleanly
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await this.statesArchiverStrategy.maybeArchiveState(finalized, this.metrics);
+      timer?.({source: ArchiveStoreTask.MaybeArchiveState});
 
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       this.chain.regen.pruneOnFinalized(finalizedEpoch);
+      timer?.({source: ArchiveStoreTask.RegenPruneOnFinalized});
 
       // tasks rely on extended fork choice
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       const prunedBlocks = this.chain.forkChoice.prune(finalized.rootHex);
+      timer?.({source: ArchiveStoreTask.ForkchoicePrune});
+
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await updateBackfillRange({chain: this.chain, db: this.db, logger: this.logger}, finalized);
+      timer?.({source: ArchiveStoreTask.UpdateBackfillRange});
 
       this.logger.verbose("Finish processing finalized checkpoint", {
         epoch: finalizedEpoch,

package/src/chain/archiveStore/strategies/frequencyStateArchiveStrategy.ts

@@ -17,6 +17,15 @@ import {StateArchiveStrategy, StatesArchiveOpts} from "../interface.js";
  */
 export const PERSIST_TEMP_STATE_EVERY_EPOCHS = 32;
 
+export enum FrequencyStateArchiveStep {
+  LoadLastStoredSlot = "load_last_stored_slot",
+  GetFinalizedState = "get_finalized_state",
+  // SerializeState is tracked via stateSerializeDuration metric
+  PersistState = "persist_state",
+  LoadStoredSlotsToDelete = "load_stored_slots_to_delete",
+  DeleteOldStates = "delete_old_states",
+}
+
 /**
  * Archives finalized states from active bucket to archive bucket.
  *
@@ -47,11 +56,16 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
    * ```
    */
   async maybeArchiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void> {
+    let timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
     const lastStoredSlot = await this.db.stateArchive.lastKey();
+    timer?.({step: FrequencyStateArchiveStep.LoadLastStoredSlot});
+
     const lastStoredEpoch = computeEpochAtSlot(lastStoredSlot ?? 0);
     const {archiveStateEpochFrequency} = this.opts;
 
+    const logCtx = {finalizedEpoch: finalized.epoch, lastStoredEpoch, archiveStateEpochFrequency};
     if (finalized.epoch - lastStoredEpoch >= Math.min(PERSIST_TEMP_STATE_EVERY_EPOCHS, archiveStateEpochFrequency)) {
+      this.logger.verbose("Start archiving state", logCtx);
       await this.archiveState(finalized, metrics);
 
       // Only check the current and previous intervals
@@ -60,23 +74,29 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
         (Math.floor(finalized.epoch / archiveStateEpochFrequency) - 1) * archiveStateEpochFrequency
       );
 
+      timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
       const storedStateSlots = await this.db.stateArchive.keys({
         lt: computeStartSlotAtEpoch(finalized.epoch),
         gte: computeStartSlotAtEpoch(minEpoch),
       });
+      timer?.({step: FrequencyStateArchiveStep.LoadStoredSlotsToDelete});
 
       const statesSlotsToDelete = computeStateSlotsToDelete(storedStateSlots, archiveStateEpochFrequency);
+      timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
       if (statesSlotsToDelete.length > 0) {
         await this.db.stateArchive.batchDelete(statesSlotsToDelete);
       }
+      timer?.({step: FrequencyStateArchiveStep.DeleteOldStates});
 
       // More logs to investigate the rss spike issue https://github.com/ChainSafe/lodestar/issues/5591
       this.logger.verbose("Archived state completed", {
-        finalizedEpoch: finalized.epoch,
+        ...logCtx,
         minEpoch,
         storedStateSlots: storedStateSlots.join(","),
         statesSlotsToDelete: statesSlotsToDelete.join(","),
       });
+    } else {
+      this.logger.verbose("Skip archiving state", logCtx);
     }
   }
 
@@ -86,24 +106,31 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
    */
   async archiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void> {
     // starting from Mar 2024, the finalized state could be from disk or in memory
+    let timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
     const finalizedStateOrBytes = await this.regen.getCheckpointStateOrBytes(finalized);
+    timer?.({step: FrequencyStateArchiveStep.GetFinalizedState});
+
     const {rootHex} = finalized;
     if (!finalizedStateOrBytes) {
       throw Error(`No state in cache for finalized checkpoint state epoch #${finalized.epoch} root ${rootHex}`);
     }
     if (finalizedStateOrBytes instanceof Uint8Array) {
       const slot = getStateSlotFromBytes(finalizedStateOrBytes);
+      timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
       await this.db.stateArchive.putBinary(slot, finalizedStateOrBytes);
+      timer?.({step: FrequencyStateArchiveStep.PersistState});
       this.logger.verbose("Archived finalized state bytes", {epoch: finalized.epoch, slot, root: rootHex});
     } else {
       // serialize state using BufferPool if provided
-      const timer = metrics?.stateSerializeDuration.startTimer({source: AllocSource.ARCHIVE_STATE});
+      const sszTimer = metrics?.stateSerializeDuration.startTimer({source: AllocSource.ARCHIVE_STATE});
       await serializeState(
         finalizedStateOrBytes,
         AllocSource.ARCHIVE_STATE,
-        (stateBytes) => {
-          timer?.();
-          return this.db.stateArchive.putBinary(finalizedStateOrBytes.slot, stateBytes);
+        async (stateBytes) => {
+          sszTimer?.();
+          timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
+          await this.db.stateArchive.putBinary(finalizedStateOrBytes.slot, stateBytes);
+          timer?.({step: FrequencyStateArchiveStep.PersistState});
         },
         this.bufferPool
       );

package/src/chain/beaconProposerCache.ts

@@ -1,18 +1,14 @@
 import {routes} from "@lodestar/api";
 import {Epoch} from "@lodestar/types";
-import {MapDef} from "@lodestar/utils";
 
 const PROPOSER_PRESERVE_EPOCHS = 2;
 
 export type ProposerPreparationData = routes.validator.ProposerPreparationData;
 
 export class BeaconProposerCache {
-  private readonly feeRecipientByValidatorIndex: MapDef<number, {epoch: Epoch; feeRecipient: string}>;
-  constructor(opts: {suggestedFeeRecipient: string}) {
-    this.feeRecipientByValidatorIndex = new MapDef(() => ({
-      epoch: 0,
-      feeRecipient: opts.suggestedFeeRecipient,
-    }));
+  private readonly feeRecipientByValidatorIndex: Map<number, {epoch: Epoch; feeRecipient: string}>;
+  constructor(readonly opts: {suggestedFeeRecipient: string}) {
+    this.feeRecipientByValidatorIndex = new Map();
   }
 
   add(epoch: Epoch, {validatorIndex, feeRecipient}: ProposerPreparationData): void {
@@ -30,7 +26,7 @@ export class BeaconProposerCache {
   }
 
   getOrDefault(proposerIndex: number): string {
-    return this.feeRecipientByValidatorIndex.getOrDefault(proposerIndex).feeRecipient;
+    return this.feeRecipientByValidatorIndex.get(proposerIndex)?.feeRecipient ?? this.opts.suggestedFeeRecipient;
   }
 
   get(proposerIndex: number): string | undefined {

package/src/chain/chain.ts

@@ -257,7 +257,7 @@ export class BeaconChain implements IBeaconChain {
     this.attestationPool = new AttestationPool(config, clock, this.opts?.preaggregateSlotDistance, metrics);
     this.aggregatedAttestationPool = new AggregatedAttestationPool(this.config, metrics);
     this.syncCommitteeMessagePool = new SyncCommitteeMessagePool(config, clock, this.opts?.preaggregateSlotDistance);
-    this.syncContributionAndProofPool = new SyncContributionAndProofPool(clock, metrics, logger);
+    this.syncContributionAndProofPool = new SyncContributionAndProofPool(config, clock, metrics, logger);
 
     this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
     this.seenContributionAndProof = new SeenContributionAndProof(metrics);
@@ -372,7 +372,7 @@ export class BeaconChain implements IBeaconChain {
     });
 
     if (!opts.disableLightClientServer) {
-      this.lightClientServer = new LightClientServer(opts, {config, db, metrics, emitter, logger});
+      this.lightClientServer = new LightClientServer(opts, {config, clock, db, metrics, emitter, logger});
     }
 
     this.reprocessController = new ReprocessController(this.metrics);

package/src/chain/errors/dataColumnSidecarError.ts

@@ -8,6 +8,7 @@ export enum DataColumnSidecarErrorCode {
   MISMATCHED_LENGTHS = "DATA_COLUMN_SIDECAR_ERROR_MISMATCHED_LENGTHS",
   INVALID_SUBNET = "DATA_COLUMN_SIDECAR_ERROR_INVALID_SUBNET",
   INVALID_KZG_PROOF = "DATA_COLUMN_SIDECAR_ERROR_INVALID_KZG_PROOF",
+  TOO_MANY_KZG_COMMITMENTS = "DATA_COLUMN_SIDECAR_ERROR_TOO_MANY_KZG_COMMITMENTS",
 
   // Validation errors when validating against an existing block
 
@@ -43,6 +44,13 @@ export type DataColumnSidecarErrorType =
       proofsLength: number;
     }
   | {code: DataColumnSidecarErrorCode.INVALID_SUBNET; columnIdx: number; gossipSubnet: SubnetID}
+  | {
+      code: DataColumnSidecarErrorCode.TOO_MANY_KZG_COMMITMENTS;
+      slot: number;
+      columnIdx: number;
+      count: number;
+      limit: number;
+    }
   | {code: DataColumnSidecarErrorCode.ALREADY_KNOWN; columnIdx: number; slot: Slot}
   | {code: DataColumnSidecarErrorCode.FUTURE_SLOT; blockSlot: Slot; currentSlot: Slot}
   | {code: DataColumnSidecarErrorCode.WOULD_REVERT_FINALIZED_SLOT; blockSlot: Slot; finalizedSlot: Slot}

package/src/chain/errors/voluntaryExitError.ts

@@ -1,13 +1,41 @@
+import {VoluntaryExitValidity} from "@lodestar/state-transition";
 import {GossipActionError} from "./gossipValidation.js";
 
 export enum VoluntaryExitErrorCode {
   ALREADY_EXISTS = "VOLUNTARY_EXIT_ERROR_ALREADY_EXISTS",
-  INVALID = "VOLUNTARY_EXIT_ERROR_INVALID",
+  INACTIVE = "VOLUNTARY_EXIT_ERROR_INACTIVE",
+  ALREADY_EXITED = "VOLUNTARY_EXIT_ERROR_ALREADY_EXITED",
+  EARLY_EPOCH = "VOLUNTARY_EXIT_ERROR_EARLY_EPOCH",
+  SHORT_TIME_ACTIVE = "VOLUNTARY_EXIT_ERROR_SHORT_TIME_ACTIVE",
+  PENDING_WITHDRAWALS = "VOLUNTARY_EXIT_ERROR_PENDING_WITHDRAWALS",
   INVALID_SIGNATURE = "VOLUNTARY_EXIT_ERROR_INVALID_SIGNATURE",
 }
 export type VoluntaryExitErrorType =
   | {code: VoluntaryExitErrorCode.ALREADY_EXISTS}
-  | {code: VoluntaryExitErrorCode.INVALID}
+  | {code: VoluntaryExitErrorCode.INACTIVE}
+  | {code: VoluntaryExitErrorCode.ALREADY_EXITED}
+  | {code: VoluntaryExitErrorCode.EARLY_EPOCH}
+  | {code: VoluntaryExitErrorCode.SHORT_TIME_ACTIVE}
+  | {code: VoluntaryExitErrorCode.PENDING_WITHDRAWALS}
   | {code: VoluntaryExitErrorCode.INVALID_SIGNATURE};
 
 export class VoluntaryExitError extends GossipActionError<VoluntaryExitErrorType> {}
+
+export function voluntaryExitValidityToErrorCode(
+  validity: Exclude<VoluntaryExitValidity, VoluntaryExitValidity.valid>
+): VoluntaryExitErrorCode {
+  switch (validity) {
+    case VoluntaryExitValidity.inactive:
+      return VoluntaryExitErrorCode.INACTIVE;
+    case VoluntaryExitValidity.alreadyExited:
+      return VoluntaryExitErrorCode.ALREADY_EXITED;
+    case VoluntaryExitValidity.earlyEpoch:
+      return VoluntaryExitErrorCode.EARLY_EPOCH;
+    case VoluntaryExitValidity.shortTimeActive:
+      return VoluntaryExitErrorCode.SHORT_TIME_ACTIVE;
+    case VoluntaryExitValidity.pendingWithdrawals:
+      return VoluntaryExitErrorCode.PENDING_WITHDRAWALS;
+    case VoluntaryExitValidity.invalidSignature:
+      return VoluntaryExitErrorCode.INVALID_SIGNATURE;
+  }
+}

package/src/chain/lightClient/index.ts

@@ -14,6 +14,7 @@ import {
   ForkPreGloas,
   ForkSeq,
   MIN_SYNC_COMMITTEE_PARTICIPANTS,
+  SLOTS_PER_EPOCH,
   SYNC_COMMITTEE_SIZE,
   forkPostAltair,
   highestFork,
@@ -51,6 +52,7 @@ import {IBeaconDb} from "../../db/index.js";
 import {NUM_WITNESS, NUM_WITNESS_ELECTRA} from "../../db/repositories/lightclientSyncCommitteeWitness.js";
 import {Metrics} from "../../metrics/index.js";
 import {byteArrayEquals} from "../../util/bytes.js";
+import {IClock} from "../../util/clock.js";
 import {ChainEventEmitter} from "../emitter.js";
 import {LightClientServerError, LightClientServerErrorCode} from "../errors/lightClientError.js";
 import {
@@ -86,6 +88,7 @@ export type SyncAttestedData = {
 
 type LightClientServerModules = {
   config: ChainForkConfig;
+  clock: IClock;
   db: IBeaconDb;
   metrics: Metrics | null;
   emitter: ChainEventEmitter;
@@ -201,6 +204,7 @@ export class LightClientServer {
   private readonly metrics: Metrics | null;
   private readonly emitter: ChainEventEmitter;
   private readonly logger: Logger;
+  private readonly clock: IClock;
   private readonly knownSyncCommittee = new MapDef<SyncPeriod, Set<DependentRootHex>>(() => new Set());
   private storedCurrentSyncCommittee = false;
 
@@ -221,8 +225,9 @@ export class LightClientServer {
     private readonly opts: LightClientServerOpts,
     modules: LightClientServerModules
   ) {
-    const {config, db, metrics, emitter, logger} = modules;
+    const {config, clock, db, metrics, emitter, logger} = modules;
     this.config = config;
+    this.clock = clock;
     this.db = db;
     this.metrics = metrics;
     this.emitter = emitter;
@@ -533,12 +538,19 @@ export class LightClientServer {
     // Fork of LightClientOptimisticUpdate and LightClientFinalityUpdate is based off on attested header's fork
     const attestedFork = this.config.getForkName(attestedHeader.beacon.slot);
 
-    // Emit update
-    // Note: Always emit optimistic update even if we have emitted one with higher or equal attested_header.slot
-    this.emitter.emit(routes.events.EventType.lightClientOptimisticUpdate, {
-      version: attestedFork,
-      data: headerUpdate,
-    });
+    // Check if node is syncing / too far behind to avoid emitting stale light client updates
+    const isStaleLightClientUpdate = this.clock.currentSlot - signatureSlot > SLOTS_PER_EPOCH;
+
+    if (!isStaleLightClientUpdate) {
+      // Emit update
+      // Note: Always emit optimistic update even if we have emitted one with higher or equal attested_header.slot
+      this.emitter.emit(routes.events.EventType.lightClientOptimisticUpdate, {
+        version: attestedFork,
+        data: headerUpdate,
+      });
+    } else {
+      this.metrics?.lightclientServer.staleLightClientUpdates.inc();
+    }
 
     // Persist latest best update for getLatestHeadUpdate()
     // TODO: Once SyncAggregate are constructed from P2P too, count bits to decide "best"
@@ -569,11 +581,13 @@ export class LightClientServer {
         };
         this.metrics?.lightclientServer.onSyncAggregate.inc({event: "update_latest_finalized_update"});
 
-        // Note: Ignores gossip rule to always emit finality_update with higher finalized_header.slot, for simplicity
-        this.emitter.emit(routes.events.EventType.lightClientFinalityUpdate, {
-          version: attestedFork,
-          data: this.finalized,
-        });
+        if (!isStaleLightClientUpdate) {
+          // Note: Ignores gossip rule to always emit finality_update with higher finalized_header.slot, for simplicity
+          this.emitter.emit(routes.events.EventType.lightClientFinalityUpdate, {
+            version: attestedFork,
+            data: this.finalized,
+          });
+        }
       }
     }
 

package/src/chain/opPools/syncContributionAndProofPool.ts

@@ -1,10 +1,10 @@
 import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {BitArray} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
 import {Root, Slot, SubnetID, altair, ssz} from "@lodestar/types";
 import {Logger, MapDef, toRootHex} from "@lodestar/utils";
-import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../../constants/constants.js";
 import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
@@ -51,6 +51,7 @@ export class SyncContributionAndProofPool {
   private lowestPermissibleSlot = 0;
 
   constructor(
+    private readonly config: ChainForkConfig,
     private readonly clock: IClock,
     private readonly metrics: Metrics | null = null,
     private logger: Logger | null = null
@@ -92,7 +93,7 @@ export class SyncContributionAndProofPool {
 
     // Reject ContributionAndProofs of previous slots
     // for api ContributionAndProofs, we allow them to be added to the pool
-    if (!priority && slot < this.clock.slotWithPastTolerance(MAXIMUM_GOSSIP_CLOCK_DISPARITY)) {
+    if (!priority && slot < this.clock.slotWithPastTolerance(this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000)) {
       return InsertOutcome.Late;
     }
 

package/src/chain/validation/attestation.ts

@@ -36,7 +36,6 @@ import {
   ssz,
 } from "@lodestar/types";
 import {assert, toRootHex} from "@lodestar/utils";
-import {MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC} from "../../constants/index.js";
 import {sszDeserializeSingleAttestation} from "../../network/gossip/topic.js";
 import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
 import {
@@ -570,8 +569,8 @@ async function validateAttestationNoSignatureCheck(
  * Note: We do not queue future attestations for later processing
  */
 export function verifyPropagationSlotRange(fork: ForkName, chain: IBeaconChain, attestationSlot: Slot): void {
-  // slot with future tolerance of MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC
-  const latestPermissibleSlot = chain.clock.slotWithFutureTolerance(MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC);
+  // slot with future tolerance of MAXIMUM_GOSSIP_CLOCK_DISPARITY
+  const latestPermissibleSlot = chain.clock.slotWithFutureTolerance(chain.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000);
   if (attestationSlot > latestPermissibleSlot) {
     throw new AttestationError(GossipAction.IGNORE, {
       code: AttestationErrorCode.FUTURE_SLOT,
@@ -586,9 +585,9 @@ export function verifyPropagationSlotRange(fork: ForkName, chain: IBeaconChain,
   // see: https://github.com/ethereum/consensus-specs/pull/3360
   if (ForkSeq[fork] < ForkSeq.deneb) {
     const earliestPermissibleSlot = Math.max(
-      // slot with past tolerance of MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC
-      // ATTESTATION_PROPAGATION_SLOT_RANGE = SLOTS_PER_EPOCH
-      chain.clock.slotWithPastTolerance(MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC) - SLOTS_PER_EPOCH,
+      // slot with past tolerance of MAXIMUM_GOSSIP_CLOCK_DISPARITY
+      chain.clock.slotWithPastTolerance(chain.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000) -
+        chain.config.ATTESTATION_PROPAGATION_SLOT_RANGE,
       0
     );
 
@@ -614,7 +613,7 @@ export function verifyPropagationSlotRange(fork: ForkName, chain: IBeaconChain,
 
     // lower bound for previous epoch is same as epoch of earliestPermissibleSlot
     const currentEpochWithPastTolerance = computeEpochAtSlot(
-      chain.clock.slotWithPastTolerance(MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC)
+      chain.clock.slotWithPastTolerance(chain.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000)
     );
 
     const earliestPermissiblePreviousEpoch = Math.max(currentEpochWithPastTolerance - 1, 0);

package/src/chain/validation/block.ts

@@ -11,7 +11,6 @@ import {
 } from "@lodestar/state-transition";
 import {SignedBeaconBlock, deneb} from "@lodestar/types";
 import {sleep, toRootHex} from "@lodestar/utils";
-import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../../constants/index.js";
 import {BlockErrorCode, BlockGossipError, GossipAction} from "../errors/index.js";
 import {IBeaconChain} from "../interface.js";
 import {RegenCaller} from "../regen/index.js";
@@ -179,7 +178,7 @@ export async function validateGossipBlock(
   // gossip validation promise without any extra infrastructure.
   // Do the sleep at the end, since regen and signature validation can already take longer than `msToBlockSlot`.
   const msToBlockSlot = computeTimeAtSlot(config, blockSlot, chain.genesisTime) * 1000 - Date.now();
-  if (msToBlockSlot <= MAXIMUM_GOSSIP_CLOCK_DISPARITY && msToBlockSlot > 0) {
+  if (msToBlockSlot <= config.MAXIMUM_GOSSIP_CLOCK_DISPARITY && msToBlockSlot > 0) {
     // If block is between 0 and 500 ms early, hold it in a promise. Equivalent to a pending queue.
     await sleep(msToBlockSlot);
   }

package/src/chain/validation/dataColumnSidecar.ts

@@ -1,10 +1,14 @@
-import {ChainConfig} from "@lodestar/config";
+import {ChainConfig, ChainForkConfig} from "@lodestar/config";
 import {
   KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH,
   KZG_COMMITMENTS_SUBTREE_INDEX,
   NUMBER_OF_COLUMNS,
 } from "@lodestar/params";
-import {computeStartSlotAtEpoch, getBlockHeaderProposerSignatureSet} from "@lodestar/state-transition";
+import {
+  computeEpochAtSlot,
+  computeStartSlotAtEpoch,
+  getBlockHeaderProposerSignatureSet,
+} from "@lodestar/state-transition";
 import {Root, Slot, SubnetID, fulu, ssz} from "@lodestar/types";
 import {toRootHex, verifyMerkleBranch} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
@@ -29,7 +33,7 @@ export async function validateGossipDataColumnSidecar(
   const blockHeader = dataColumnSidecar.signedBlockHeader.message;
 
   // 1) [REJECT] The sidecar is valid as verified by verify_data_column_sidecar
-  verifyDataColumnSidecar(dataColumnSidecar);
+  verifyDataColumnSidecar(chain.config, dataColumnSidecar);
 
   // 2) [REJECT] The sidecar is for the correct subnet -- i.e. compute_subnet_for_data_column_sidecar(sidecar.index) == subnet_id
   if (computeSubnetForDataColumnSidecar(chain.config, dataColumnSidecar) !== gossipSubnet) {
@@ -184,7 +188,7 @@ export async function validateGossipDataColumnSidecar(
  * SPEC FUNCTION
  * https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/p2p-interface.md#verify_data_column_sidecar
  */
-function verifyDataColumnSidecar(dataColumnSidecar: fulu.DataColumnSidecar): void {
+function verifyDataColumnSidecar(config: ChainForkConfig, dataColumnSidecar: fulu.DataColumnSidecar): void {
   if (dataColumnSidecar.index >= NUMBER_OF_COLUMNS) {
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.INVALID_INDEX,
@@ -201,6 +205,19 @@ function verifyDataColumnSidecar(dataColumnSidecar: fulu.DataColumnSidecar): voi
     });
   }
 
+  const epoch = computeEpochAtSlot(dataColumnSidecar.signedBlockHeader.message.slot);
+  const maxBlobsPerBlock = config.getMaxBlobsPerBlock(epoch);
+
+  if (dataColumnSidecar.kzgCommitments.length > maxBlobsPerBlock) {
+    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+      code: DataColumnSidecarErrorCode.TOO_MANY_KZG_COMMITMENTS,
+      slot: dataColumnSidecar.signedBlockHeader.message.slot,
+      columnIdx: dataColumnSidecar.index,
+      count: dataColumnSidecar.kzgCommitments.length,
+      limit: maxBlobsPerBlock,
+    });
+  }
+
   if (
     dataColumnSidecar.column.length !== dataColumnSidecar.kzgCommitments.length ||
     dataColumnSidecar.column.length !== dataColumnSidecar.kzgProofs.length

package/src/chain/validation/lightClientOptimisticUpdate.ts

@@ -1,6 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {LightClientOptimisticUpdate} from "@lodestar/types";
-import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../../constants/index.js";
 import {assertLightClientServer} from "../../node/utils/lightclient.js";
 import {IClock} from "../../util/clock.js";
 import {GossipAction} from "../errors/index.js";
@@ -64,5 +63,7 @@ export function updateReceivedTooEarly(
   update: Pick<LightClientOptimisticUpdate, "signatureSlot">
 ): boolean {
   const fork = config.getForkName(update.signatureSlot);
-  return clock.msFromSlot(update.signatureSlot) < config.getSyncMessageDueMs(fork) - MAXIMUM_GOSSIP_CLOCK_DISPARITY;
+  return (
+    clock.msFromSlot(update.signatureSlot) < config.getSyncMessageDueMs(fork) - config.MAXIMUM_GOSSIP_CLOCK_DISPARITY
+  );
 }

package/src/chain/validation/voluntaryExit.ts

@@ -1,6 +1,15 @@
-import {getVoluntaryExitSignatureSet, isValidVoluntaryExit} from "@lodestar/state-transition";
+import {
+  VoluntaryExitValidity,
+  getVoluntaryExitSignatureSet,
+  getVoluntaryExitValidity,
+} from "@lodestar/state-transition";
 import {phase0} from "@lodestar/types";
-import {GossipAction, VoluntaryExitError, VoluntaryExitErrorCode} from "../errors/index.js";
+import {
+  GossipAction,
+  VoluntaryExitError,
+  VoluntaryExitErrorCode,
+  voluntaryExitValidityToErrorCode,
+} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
 import {RegenCaller} from "../regen/index.js";
 
@@ -43,9 +52,10 @@ async function validateVoluntaryExit(
 
   // [REJECT] All of the conditions within process_voluntary_exit pass validation.
   // verifySignature = false, verified in batch below
-  if (!isValidVoluntaryExit(chain.config.getForkSeq(state.slot), state, voluntaryExit, false)) {
+  const validity = getVoluntaryExitValidity(chain.config.getForkSeq(state.slot), state, voluntaryExit, false);
+  if (validity !== VoluntaryExitValidity.valid) {
     throw new VoluntaryExitError(GossipAction.REJECT, {
-      code: VoluntaryExitErrorCode.INVALID,
+      code: voluntaryExitValidityToErrorCode(validity),
     });
   }
 

package/src/constants/constants.ts

@@ -7,9 +7,3 @@ export const ZERO_HASH = Buffer.alloc(32, 0);
 export const ZERO_HASH_HEX = "0x" + "00".repeat(32);
 export const EMPTY_SIGNATURE = Buffer.alloc(96, 0);
 export const GRAFFITI_SIZE = 32;
-
-/**
- * The maximum milliseconds of clock disparity assumed between honest nodes.
- */
-export const MAXIMUM_GOSSIP_CLOCK_DISPARITY = 500;
-export const MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC = MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000;

package/src/constants/network.ts

@@ -1,22 +1,3 @@
-/**
- * For more info on some of these constants:
- * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#configuration
- */
-
-// Gossip constants
-
-/**
- * The maximum number of slots during which an attestation can be propagated.
- */
-export const ATTESTATION_PROPAGATION_SLOT_RANGE = 32;
-
-/** The maximum allowed size of uncompressed gossip messages. */
-export const GOSSIP_MAX_SIZE = 2 ** 20;
-export const GOSSIP_MAX_SIZE_BELLATRIX = 10 * GOSSIP_MAX_SIZE;
-/** The maximum allowed size of uncompressed req/resp chunked responses. */
-export const MAX_CHUNK_SIZE = 2 ** 20;
-export const MAX_CHUNK_SIZE_BELLATRIX = 10 * MAX_CHUNK_SIZE;
-
 export enum GoodByeReasonCode {
   INBOUND_DISCONNECT = -1,
   CLIENT_SHUTDOWN = 1,

package/src/metrics/metrics/lodestar.ts

@@ -1,5 +1,7 @@
 /** biome-ignore-all lint/suspicious/noTemplateCurlyInString: The metric templates requires to have `${}` in a normal string */
 import {NotReorgedReason} from "@lodestar/fork-choice";
+import {ArchiveStoreTask} from "../../chain/archiveStore/archiveStore.js";
+import {FrequencyStateArchiveStep} from "../../chain/archiveStore/strategies/frequencyStateArchiveStrategy.js";
 import {BlockInputSource} from "../../chain/blocks/blockInput/index.js";
 import {JobQueueItemType} from "../../chain/bls/index.js";
 import {AttestationErrorCode, BlockErrorCode} from "../../chain/errors/index.js";
@@ -1420,6 +1422,21 @@ export function createLodestarMetrics(
       },
     },
 
+    processFinalizedCheckpoint: {
+      durationByTask: register.histogram<{source: ArchiveStoreTask}>({
+        name: "lodestar_process_finalized_checkpoint_seconds",
+        help: "Histogram of time to process finalized checkpoint",
+        buckets: [0.1, 0.5, 1, 2, 4, 8],
+        labelNames: ["source"],
+      }),
+      frequencyStateArchive: register.histogram<{step: FrequencyStateArchiveStep}>({
+        name: "lodestar_process_finalized_checkpoint_frequency_state_archive_seconds",
+        help: "Histogram of FrequencyStateArchive duration by step",
+        buckets: [0.1, 0.5, 1, 2, 4, 8],
+        labelNames: ["step"],
+      }),
+    },
+
     regenFnCallTotal: register.gauge<{entrypoint: RegenFnName; caller: RegenCaller}>({
       name: "lodestar_regen_fn_call_total",
       help: "Total number of calls for regen functions",
@@ -1596,6 +1613,10 @@ export function createLodestarMetrics(
         name: "lodestar_lightclient_server_attested_data_diff_period_total",
         help: "Total number of times a syncAggregate is a different period than attested data",
       }),
+      staleLightClientUpdates: register.counter({
+        name: "lodestar_lightclient_server_stale_updates_total",
+        help: "Total number of stale light client updates that were not emitted",
+      }),
     },
 
     eth1: {

package/src/network/discv5/utils.ts

@@ -1,6 +1,5 @@
 import {ENR} from "@chainsafe/enr";
 import {BeaconConfig} from "@lodestar/config";
-import {MAXIMUM_GOSSIP_CLOCK_DISPARITY} from "../../constants/constants.js";
 import {IClock} from "../../util/clock.js";
 import {ENRKey} from "../metadata.js";
 
@@ -35,7 +34,7 @@ export function enrRelevance(enr: ENR, config: BeaconConfig, clock: IClock): ENR
   }
 
   // Check if fork digest's fork matches ours
-  const currentSlot = clock.slotWithFutureTolerance(MAXIMUM_GOSSIP_CLOCK_DISPARITY);
+  const currentSlot = clock.slotWithFutureTolerance(config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000);
   const localForkInfo = config.getForkInfo(currentSlot);
   // We only connect if the ENR's fork matches our current fork.
   // We also allow it to be the previous fork due to delay and infrequent update of DHT.