@lodestar/beacon-node 1.36.0-dev.a2a22d66ef → 1.36.0-dev.b53af9d0a5

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.

package/src/network/gossip/gossipsub.ts

@@ -6,7 +6,6 @@ import {BeaconConfig, ForkBoundary} from "@lodestar/config";
 import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
 import {SubnetID} from "@lodestar/types";
 import {Logger, Map2d, Map2dArr} from "@lodestar/utils";
-import {GOSSIP_MAX_SIZE, GOSSIP_MAX_SIZE_BELLATRIX} from "../../constants/network.js";
 import {RegistryMetricCreator} from "../../metrics/index.js";
 import {callInNextEventLoop} from "../../util/eventLoop.js";
 import {NetworkEvent, NetworkEventBus, NetworkEventData} from "../events.js";
@@ -117,15 +116,7 @@ export class Eth2Gossipsub extends GossipSub {
       fastMsgIdFn: fastMsgIdFn,
       msgIdFn: msgIdFn.bind(msgIdFn, gossipTopicCache),
       msgIdToStrFn: msgIdToStrFn,
-      // Use the bellatrix max size if the merge is configured. pre-merge using this size
-      // could only be an issue on outgoing payloads, its highly unlikely we will send out
-      // a chunk bigger than GOSSIP_MAX_SIZE pre merge even on mainnet network.
-      //
-      // TODO: figure out a way to dynamically transition to the size
-      dataTransform: new DataTransformSnappy(
-        gossipTopicCache,
-        Number.isFinite(config.BELLATRIX_FORK_EPOCH) ? GOSSIP_MAX_SIZE_BELLATRIX : GOSSIP_MAX_SIZE
-      ),
+      dataTransform: new DataTransformSnappy(gossipTopicCache, config.MAX_PAYLOAD_SIZE),
       metricsRegister: metricsRegister as MetricsRegister | null,
       metricsTopicStrToLabel: metricsRegister
         ? getMetricsTopicStrToLabel(networkConfig, {disableLightClientServer: opts.disableLightClientServer ?? false})

package/src/network/processor/gossipHandlers.ts

@@ -556,6 +556,16 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           metrics?.dataColumns.elapsedTimeTillReceived.observe({receivedOrder: receivedColumns}, delaySec);
           break;
       }
+
+      if (!blockInput.hasAllData()) {
+        // immediately attempt fetch of data columns from execution engine
+        chain.getBlobsTracker.triggerGetBlobs(blockInput);
+        // if we've received at least half of the columns, trigger reconstruction of the rest
+        if (blockInput.columnCount >= NUMBER_OF_COLUMNS / 2) {
+          chain.columnReconstructionTracker.triggerColumnReconstruction(blockInput);
+        }
+      }
+
       if (!blockInput.hasBlockAndAllData()) {
         const cutoffTimeMs = getCutoffTimeMs(chain, dataColumnSlot, BLOCK_AVAILABILITY_CUTOFF_MS);
         chain.logger.debug("Received gossip data column, waiting for full data availability", {
@@ -578,12 +588,6 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
             source: BlockInputSource.gossip,
           });
         });
-        // immediately attempt fetch of data columns from execution engine
-        chain.getBlobsTracker.triggerGetBlobs(blockInput);
-        // if we've received at least half of the columns, trigger reconstruction of the rest
-        if (blockInput.columnCount >= NUMBER_OF_COLUMNS / 2) {
-          chain.columnReconstructionTracker.triggerColumnReconstruction(blockInput);
-        }
       }
     },
 

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

@@ -1,5 +1,5 @@
 import {ChainConfig} from "@lodestar/config";
-import {BLOBSIDECAR_FIXED_SIZE, GENESIS_SLOT} from "@lodestar/params";
+import {BLOB_SIDECAR_FIXED_SIZE, GENESIS_SLOT} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {Slot, deneb} from "@lodestar/types";
@@ -71,17 +71,17 @@ export function* iterateBlobBytesFromWrapper(
   blockSlot: Slot
 ): Iterable<ResponseOutgoing> {
   const allBlobSideCarsBytes = blobSideCarsBytesWrapped.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
-  const blobsLen = allBlobSideCarsBytes.length / BLOBSIDECAR_FIXED_SIZE;
+  const blobsLen = allBlobSideCarsBytes.length / BLOB_SIDECAR_FIXED_SIZE;
 
   for (let index = 0; index < blobsLen; index++) {
     const blobSideCarBytes = allBlobSideCarsBytes.slice(
-      index * BLOBSIDECAR_FIXED_SIZE,
-      (index + 1) * BLOBSIDECAR_FIXED_SIZE
+      index * BLOB_SIDECAR_FIXED_SIZE,
+      (index + 1) * BLOB_SIDECAR_FIXED_SIZE
     );
-    if (blobSideCarBytes.length !== BLOBSIDECAR_FIXED_SIZE) {
+    if (blobSideCarBytes.length !== BLOB_SIDECAR_FIXED_SIZE) {
       throw new ResponseError(
         RespStatus.SERVER_ERROR,
-        `Invalid blobSidecar index=${index} bytes length=${blobSideCarBytes.length} expected=${BLOBSIDECAR_FIXED_SIZE} for slot ${blockSlot} blobsLen=${blobsLen}`
+        `Invalid blobSidecar index=${index} bytes length=${blobSideCarBytes.length} expected=${BLOB_SIDECAR_FIXED_SIZE} for slot ${blockSlot} blobsLen=${blobsLen}`
       );
     }
     yield {

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

@@ -1,4 +1,4 @@
-import {BLOBSIDECAR_FIXED_SIZE} from "@lodestar/params";
+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";
@@ -45,12 +45,12 @@ export async function* onBlobSidecarsByRoot(
     }
 
     const blobSidecarBytes = lastFetchedSideCars.bytes.slice(
-      index * BLOBSIDECAR_FIXED_SIZE,
-      (index + 1) * BLOBSIDECAR_FIXED_SIZE
+      index * BLOB_SIDECAR_FIXED_SIZE,
+      (index + 1) * BLOB_SIDECAR_FIXED_SIZE
     );
-    if (blobSidecarBytes.length !== BLOBSIDECAR_FIXED_SIZE) {
+    if (blobSidecarBytes.length !== BLOB_SIDECAR_FIXED_SIZE) {
       throw Error(
-        `Inconsistent state, blobSidecar blockRoot=${blockRootHex} index=${index} blobSidecarBytes=${blobSidecarBytes.length} expected=${BLOBSIDECAR_FIXED_SIZE}`
+        `Inconsistent state, blobSidecar blockRoot=${blockRootHex} index=${index} blobSidecarBytes=${blobSidecarBytes.length} expected=${BLOB_SIDECAR_FIXED_SIZE}`
       );
     }
 

package/src/network/subnets/attnetsService.ts

@@ -1,5 +1,5 @@
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
-import {ATTESTATION_SUBNET_COUNT, EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {Epoch, Slot, SubnetID, ssz} from "@lodestar/types";
 import {Logger, MapDef} from "@lodestar/utils";
@@ -92,8 +92,8 @@ export class AttnetsService implements IAttnetsService {
     const shortLivedSubnets = this.committeeSubnets.getActiveTtl(this.clock.currentSlot);
 
     const longLivedSubscriptionsToSlot =
-      (Math.floor(this.clock.currentEpoch / EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION) + 1) *
-      EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION *
+      (Math.floor(this.clock.currentEpoch / this.config.EPOCHS_PER_SUBNET_SUBSCRIPTION) + 1) *
+      this.config.EPOCHS_PER_SUBNET_SUBSCRIPTION *
       SLOTS_PER_EPOCH;
     const longLivedSubnets = Array.from(this.longLivedSubscriptions).map((subnet) => ({
       subnet,
@@ -234,11 +234,11 @@ export class AttnetsService implements IAttnetsService {
 
   /**
    * Run per epoch, clean-up operations that are not urgent
-   * Subscribe to new random subnets every EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION epochs
+   * Subscribe to new random subnets every EPOCHS_PER_SUBNET_SUBSCRIPTION epochs
    */
   private onEpoch = (epoch: Epoch): void => {
     try {
-      if (epoch % EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION === 0) {
+      if (epoch % this.config.EPOCHS_PER_SUBNET_SUBSCRIPTION === 0) {
         this.recomputeLongLivedSubnets();
       }
     } catch (e) {
@@ -253,7 +253,7 @@ export class AttnetsService implements IAttnetsService {
     }
 
     const oldSubnets = this.longLivedSubscriptions;
-    const newSubnets = computeSubscribedSubnet(this.nodeId, this.clock.currentEpoch);
+    const newSubnets = computeSubscribedSubnet(this.config, this.nodeId, this.clock.currentEpoch);
     this.logger.verbose("Recomputing long-lived subscriptions", {
       epoch: this.clock.currentEpoch,
       oldSubnets: Array.from(oldSubnets).join(","),

package/src/network/subnets/util.ts

@@ -1,11 +1,6 @@
 import {digest} from "@chainsafe/as-sha256";
-import {
-  ATTESTATION_SUBNET_COUNT,
-  ATTESTATION_SUBNET_PREFIX_BITS,
-  EPOCHS_PER_SUBNET_SUBSCRIPTION,
-  NODE_ID_BITS,
-  SUBNETS_PER_NODE,
-} from "@lodestar/params";
+import {ChainConfig} from "@lodestar/config";
+import {ATTESTATION_SUBNET_COUNT, ATTESTATION_SUBNET_PREFIX_BITS, NODE_ID_BITS} from "@lodestar/params";
 import {computeShuffledIndex} from "@lodestar/state-transition";
 import {Epoch, ssz} from "@lodestar/types";
 import {NodeId} from "./interface.js";
@@ -13,10 +8,10 @@ import {NodeId} from "./interface.js";
 /**
  * Spec https://github.com/ethereum/consensus-specs/blob/v1.4.0-alpha.3/specs/phase0/p2p-interface.md
  */
-export function computeSubscribedSubnet(nodeId: NodeId, epoch: Epoch): number[] {
+export function computeSubscribedSubnet(config: ChainConfig, nodeId: NodeId, epoch: Epoch): number[] {
   const subnets: number[] = [];
-  for (let index = 0; index < SUBNETS_PER_NODE; index++) {
-    subnets.push(computeSubscribedSubnetByIndex(nodeId, epoch, index));
+  for (let index = 0; index < config.SUBNETS_PER_NODE; index++) {
+    subnets.push(computeSubscribedSubnetByIndex(config, nodeId, epoch, index));
   }
   return subnets;
 }
@@ -24,11 +19,16 @@ export function computeSubscribedSubnet(nodeId: NodeId, epoch: Epoch): number[]
 /**
  * Spec https://github.com/ethereum/consensus-specs/blob/v1.4.0-alpha.3/specs/phase0/p2p-interface.md
  */
-export function computeSubscribedSubnetByIndex(nodeId: NodeId, epoch: Epoch, index: number): number {
+export function computeSubscribedSubnetByIndex(
+  config: ChainConfig,
+  nodeId: NodeId,
+  epoch: Epoch,
+  index: number
+): number {
   const nodeIdPrefix = getNodeIdPrefix(nodeId);
   const nodeOffset = getNodeOffset(nodeId);
   const permutationSeed = digest(
-    ssz.UintNum64.serialize(Math.floor((epoch + nodeOffset) / EPOCHS_PER_SUBNET_SUBSCRIPTION))
+    ssz.UintNum64.serialize(Math.floor((epoch + nodeOffset) / config.EPOCHS_PER_SUBNET_SUBSCRIPTION))
   );
   const permutatedPrefix = computeShuffledIndex(nodeIdPrefix, 1 << ATTESTATION_SUBNET_PREFIX_BITS, permutationSeed);
   return (permutatedPrefix + index) % ATTESTATION_SUBNET_COUNT;

package/src/sync/utils/remoteSyncType.ts

@@ -134,8 +134,8 @@ export function getRangeSyncTarget(
   return {
     syncType: RangeSyncType.Head,
     // The new peer has the same finalized (earlier filters should prevent a peer with an
-    // earlier finalized chain from reaching here).
-    startEpoch: Math.min(computeEpochAtSlot(local.headSlot), remote.finalizedEpoch),
+    // earlier finalized chain from reaching here) and local head will always be >= local finalized.
+    startEpoch: computeEpochAtSlot(local.headSlot),
     target: {
       slot: remote.headSlot,
       root: remote.headRoot,