@lodestar/beacon-node 1.36.0-dev.6604fa5719 → 1.36.0-dev.6832b029e7

package/src/network/core/networkCoreWorker.ts

@@ -1,5 +1,3 @@
-import fs from "node:fs";
-import path from "node:path";
 import worker from "node:worker_threads";
 import {privateKeyFromProtobuf} from "@libp2p/crypto/keys";
 import {peerIdFromPrivateKey} from "@libp2p/peer-id";
@@ -11,7 +9,7 @@ import {RegistryMetricCreator, collectNodeJSMetrics} from "../../metrics/index.j
 import {AsyncIterableBridgeCaller, AsyncIterableBridgeHandler} from "../../util/asyncIterableToEvents.js";
 import {Clock} from "../../util/clock.js";
 import {peerIdToString} from "../../util/peerId.js";
-import {profileNodeJS, writeHeapSnapshot} from "../../util/profile.js";
+import {ProfileThread, profileThread, writeHeapSnapshot} from "../../util/profile.js";
 import {wireEventsOnWorkerThread} from "../../util/workerEvents.js";
 import {NetworkEventBus, NetworkEventData, networkEventDirection} from "../events.js";
 import {
@@ -100,8 +98,13 @@ const core = await NetworkCore.init({
   metricsRegistry: metricsRegister,
   events,
   clock,
-  getReqRespHandler: (method) => (req, peerId) =>
-    reqRespBridgeRespCaller.getAsyncIterable({method, req, peerId: peerIdToString(peerId)}),
+  getReqRespHandler: (method) => (req, peerId, peerClient) =>
+    reqRespBridgeRespCaller.getAsyncIterable({
+      method,
+      req,
+      peerId: peerIdToString(peerId),
+      peerClient,
+    }),
   activeValidatorCount: workerData.activeValidatorCount,
   initialStatus: workerData.initialStatus,
   initialCustodyGroupCount: workerData.initialCustodyGroupCount,
@@ -157,10 +160,7 @@ const libp2pWorkerApi: NetworkWorkerApi = {
   dumpDiscv5KadValues: () => core.dumpDiscv5KadValues(),
   dumpMeshPeers: () => core.dumpMeshPeers(),
   writeProfile: async (durationMs: number, dirpath: string) => {
-    const profile = await profileNodeJS(durationMs);
-    const filePath = path.join(dirpath, `network_thread_${new Date().toISOString()}.cpuprofile`);
-    fs.writeFileSync(filePath, profile);
-    return filePath;
+    return profileThread(ProfileThread.NETWORK, durationMs, dirpath);
   },
   writeDiscv5Profile: async (durationMs: number, dirpath: string) => {
     return core.writeDiscv5Profile(durationMs, dirpath);

package/src/network/core/networkCoreWorkerHandler.ts

@@ -73,7 +73,7 @@ export class WorkerNetworkCore implements INetworkCore {
     // Handles ReqResp response from worker and calls async generator in main thread
     this.reqRespBridgeRespHandler = new AsyncIterableBridgeHandler(
       getReqRespBridgeRespEvents(this.reqRespBridgeEventBus),
-      (data) => modules.getReqRespHandler(data.method)(data.req, peerIdFromString(data.peerId))
+      (data) => modules.getReqRespHandler(data.method)(data.req, peerIdFromString(data.peerId), data.peerClient)
     );
 
     wireEventsOnMainThread<NetworkEventData>(

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/discv5/worker.ts

@@ -1,5 +1,3 @@
-import fs from "node:fs";
-import path from "node:path";
 import worker from "node:worker_threads";
 import {privateKeyFromProtobuf} from "@libp2p/crypto/keys";
 import {peerIdFromPrivateKey} from "@libp2p/peer-id";
@@ -14,7 +12,7 @@ import {Gauge} from "@lodestar/utils";
 import {RegistryMetricCreator} from "../../metrics/index.js";
 import {collectNodeJSMetrics} from "../../metrics/nodeJsMetrics.js";
 import {Clock} from "../../util/clock.js";
-import {profileNodeJS, writeHeapSnapshot} from "../../util/profile.js";
+import {ProfileThread, profileThread, writeHeapSnapshot} from "../../util/profile.js";
 import {Discv5WorkerApi, Discv5WorkerData} from "./types.js";
 import {ENRRelevance, enrRelevance} from "./utils.js";
 
@@ -108,10 +106,7 @@ const module: Discv5WorkerApi = {
     return (await metricsRegistry?.metrics()) ?? "";
   },
   writeProfile: async (durationMs: number, dirpath: string) => {
-    const profile = await profileNodeJS(durationMs);
-    const filePath = path.join(dirpath, `discv5_thread_${new Date().toISOString()}.cpuprofile`);
-    fs.writeFileSync(filePath, profile);
-    return filePath;
+    return profileThread(ProfileThread.DISC5, durationMs, dirpath);
   },
   writeHeapSnapshot: async (prefix: string, dirpath: string) => {
     return writeHeapSnapshot(prefix, dirpath);

package/src/network/events.ts

@@ -29,7 +29,7 @@ export type NetworkEventData = {
     clientAgent: string;
   };
   [NetworkEvent.peerDisconnected]: {peer: PeerIdStr};
-  [NetworkEvent.reqRespRequest]: {request: RequestTypedContainer; peer: PeerId};
+  [NetworkEvent.reqRespRequest]: {request: RequestTypedContainer; peer: PeerId; peerClient: string};
   [NetworkEvent.pendingGossipsubMessage]: PendingGossipsubMessage;
   [NetworkEvent.gossipMessageValidationResult]: {
     msgId: string;

package/src/network/gossip/encoding.ts

@@ -1,6 +1,6 @@
 import {Message} from "@libp2p/interface";
-import {compress, uncompress} from "snappyjs";
 import xxhashFactory from "xxhash-wasm";
+import {compress, uncompress} from "#snappy";
 import {digest} from "@chainsafe/as-sha256";
 import {RPC} from "@chainsafe/libp2p-gossipsub/message";
 import {DataTransform} from "@chainsafe/libp2p-gossipsub/types";

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})
@@ -305,6 +296,10 @@ export class Eth2Gossipsub extends GossipSub {
     // Get seenTimestamp before adding the message to the queue or add async delays
     const seenTimestampSec = Date.now() / 1000;
 
+    const peerIdStr = propagationSource.toString();
+    const clientAgent = this.peersData.getPeerKind(peerIdStr) ?? "Unknown";
+    const clientVersion = this.peersData.getAgentVersion(peerIdStr);
+
     // Use setTimeout to yield to the macro queue
     // Without this we'll have huge event loop lag
     // See https://github.com/ChainSafe/lodestar/issues/5604
@@ -314,7 +309,9 @@ export class Eth2Gossipsub extends GossipSub {
         msg,
         msgId,
         // Hot path, use cached .toString() version
-        propagationSource: propagationSource.toString(),
+        propagationSource: peerIdStr,
+        clientVersion,
+        clientAgent,
         seenTimestampSec,
         startProcessUnixSec: null,
       });

package/src/network/gossip/interface.ts

@@ -150,6 +150,8 @@ export type GossipMessageInfo = {
   topic: GossipTopic;
   msg: Message;
   propagationSource: PeerIdStr;
+  clientAgent: string;
+  clientVersion: string;
   seenTimestampSec: number;
   msgSlot: Slot | null;
   indexed?: string;

package/src/network/gossip/snappy_bun.ts

@@ -0,0 +1,2 @@
+import {snappy} from "@lodestar/bun";
+export const {compress, uncompress} = snappy;

package/src/network/metadata.ts

@@ -126,7 +126,7 @@ export class MetadataController {
    * 2. Network MUST call this method on fork transition.
    *    Current Clock implementation ensures no race conditions, epoch is correct if re-fetched
    */
-  updateEth2Field(epoch: Epoch): void {
+  updateEth2Field(epoch: Epoch): phase0.ENRForkID {
     const config = this.networkConfig.config;
     const enrForkId = getENRForkID(config, epoch);
     const {forkDigest, nextForkVersion, nextForkEpoch} = enrForkId;
@@ -143,6 +143,8 @@ export class MetadataController {
         : ssz.ForkDigest.defaultValue();
     this.onSetValue(ENRKey.nfd, nextForkDigest);
     this.logger.debug("Updated nfd field in ENR", {nextForkDigest: toHex(nextForkDigest)});
+
+    return enrForkId;
   }
 }
 

package/src/network/options.ts

@@ -23,7 +23,6 @@ export interface NetworkOptions
   useWorker?: boolean;
   maxYoungGenerationSizeMb?: number;
   disableLightClientServer?: boolean;
-  supernode?: boolean;
 
   /**
    * During E2E tests observe a lot of following `missing stream`:

package/src/network/peers/discover.ts

@@ -391,8 +391,8 @@ export class PeerDiscovery {
     // tcp multiaddr is known to be be present, checked inside the worker
     const multiaddrTCP = enr.getLocationMultiaddr(ENRKey.tcp);
     if (!multiaddrTCP) {
-      this.logger.error("Discv5 worker sent enr without tcp multiaddr", {enr: enr.encodeTxt()});
-      this.metrics?.discovery.discoveredStatus.inc({status: DiscoveredPeerStatus.error});
+      this.logger.warn("Discv5 worker sent enr without tcp multiaddr", {enr: enr.encodeTxt()});
+      this.metrics?.discovery.discoveredStatus.inc({status: DiscoveredPeerStatus.no_multiaddrs});
       return;
     }
     // Are this fields mandatory?

package/src/network/processor/gossipHandlers.ts

@@ -39,6 +39,7 @@ import {
   BlockError,
   BlockErrorCode,
   BlockGossipError,
+  DataColumnSidecarErrorCode,
   DataColumnSidecarGossipError,
   GossipAction,
   GossipActionError,
@@ -295,6 +296,21 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     const slot = dataColumnBlockHeader.slot;
     const blockRootHex = toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(dataColumnBlockHeader));
 
+    // check to see if block has already been processed and BlockInput has been deleted (column received via reqresp or other means)
+    if (chain.forkChoice.hasBlockHex(blockRootHex)) {
+      metrics?.peerDas.dataColumnSidecarProcessingSkip.inc();
+      logger.debug("Already processed block for column sidecar, skipping processing", {
+        slot,
+        blockRoot: blockRootHex,
+        index: dataColumnSidecar.index,
+      });
+      throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
+        code: DataColumnSidecarErrorCode.ALREADY_KNOWN,
+        columnIndex: dataColumnSidecar.index,
+        slot,
+      });
+    }
+
     // first check if we should even process this column (we may have already processed it via getBlobsV2)
     {
       const blockInput = chain.seenBlockInputCache.get(blockRootHex);
@@ -304,7 +320,11 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           ...blockInput.getLogMeta(),
           index: dataColumnSidecar.index,
         });
-        return blockInput;
+        throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
+          code: DataColumnSidecarErrorCode.ALREADY_KNOWN,
+          columnIndex: dataColumnSidecar.index,
+          slot,
+        });
       }
     }
 
@@ -556,6 +576,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 +608,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/processor/gossipValidatorFn.ts

@@ -11,6 +11,7 @@ import {
   GossipValidatorBatchFn,
   GossipValidatorFn,
 } from "../gossip/interface.js";
+import {prettyPrintPeerIdStr} from "../util.ts";
 
 export type ValidatorFnModules = {
   config: ChainForkConfig;
@@ -99,7 +100,15 @@ export function getGossipValidatorBatchFn(
 export function getGossipValidatorFn(gossipHandlers: GossipHandlers, modules: ValidatorFnModules): GossipValidatorFn {
   const {logger, metrics} = modules;
 
-  return async function gossipValidatorFn({topic, msg, propagationSource, seenTimestampSec, msgSlot}) {
+  return async function gossipValidatorFn({
+    topic,
+    msg,
+    propagationSource,
+    clientAgent,
+    clientVersion,
+    seenTimestampSec,
+    msgSlot,
+  }) {
     const type = topic.type;
 
     try {
@@ -134,7 +143,11 @@ export function getGossipValidatorFn(gossipHandlers: GossipHandlers, modules: Va
 
         case GossipAction.REJECT:
           metrics?.networkProcessor.gossipValidationReject.inc({topic: type});
-          logger.debug(`Gossip validation ${type} rejected`, {}, e);
+          logger.debug(
+            `Gossip validation ${type} rejected`,
+            {peerId: prettyPrintPeerIdStr(propagationSource), clientAgent, clientVersion},
+            e
+          );
           return TopicValidatorResult.Reject;
       }
     }

package/src/network/processor/types.ts

@@ -15,6 +15,8 @@ export type PendingGossipsubMessage = {
   msgSlot?: Slot;
   msgId: string;
   propagationSource: PeerIdStr;
+  clientAgent: string;
+  clientVersion: string;
   seenTimestampSec: number;
   startProcessUnixSec: number | null;
   // specific properties for IndexedGossipQueueMinSize, for beacon_attestation topic only

package/src/network/reqresp/ReqRespBeaconNode.ts

@@ -19,6 +19,7 @@ import {callInNextEventLoop} from "../../util/eventLoop.js";
 import {NetworkCoreMetrics} from "../core/metrics.js";
 import {INetworkEventBus, NetworkEvent} from "../events.js";
 import {MetadataController} from "../metadata.js";
+import {ClientKind} from "../peers/client.ts";
 import {PeersData} from "../peers/peersData.js";
 import {IPeerRpcScoreStore, PeerAction} from "../peers/score/index.js";
 import {StatusCache} from "../statusCache.js";
@@ -300,10 +301,11 @@ export class ReqRespBeaconNode extends ReqResp {
   }
 
   protected onIncomingRequestBody(request: RequestTypedContainer, peer: PeerId): void {
+    const peerClient = this.peersData.getPeerKind(peer.toString()) ?? ClientKind.Unknown;
     // Allow onRequest to return and close the stream
     // For Goodbye there may be a race condition where the listener of `receivedGoodbye`
     // disconnects in the same synchronous call, preventing the stream from ending cleanly
-    callInNextEventLoop(() => this.networkEventBus.emit(NetworkEvent.reqRespRequest, {request, peer}));
+    callInNextEventLoop(() => this.networkEventBus.emit(NetworkEvent.reqRespRequest, {request, peer, peerClient}));
   }
 
   protected onIncomingRequest(peerId: PeerId, protocol: ProtocolDescriptor): void {

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

@@ -1,25 +1,40 @@
+import {PeerId} from "@libp2p/interface";
 import {BeaconConfig} from "@lodestar/config";
-import {GENESIS_SLOT, isForkPostDeneb} from "@lodestar/params";
+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";
 
 // TODO: Unit test
 
 export async function* onBeaconBlocksByRange(
   request: phase0.BeaconBlocksByRangeRequest,
   chain: IBeaconChain,
-  db: IBeaconDb
+  db: IBeaconDb,
+  peerId: PeerId,
+  peerClient: string
 ): AsyncIterable<ResponseOutgoing> {
   const {startSlot, count} = validateBeaconBlocksByRangeRequest(chain.config, request);
   const endSlot = startSlot + count;
 
   const finalized = db.blockArchive;
   const unfinalized = db.block;
-  const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
+  // 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();
+
+  const forkName = chain.config.getForkName(startSlot);
+  if (isForkPostFulu(forkName) && startSlot < chain.earliestAvailableSlot) {
+    chain.logger.verbose("Peer did not respect earliestAvailableSlot for BeaconBlocksByRange", {
+      peer: prettyPrintPeerId(peerId),
+      client: peerClient,
+    });
+    return;
+  }
 
   // Finalized range of blocks
   if (startSlot <= finalizedSlot) {

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/reqresp/handlers/dataColumnSidecarsByRange.ts

@@ -1,3 +1,4 @@
+import {PeerId} from "@libp2p/interface";
 import {ChainConfig} from "@lodestar/config";
 import {GENESIS_SLOT} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
@@ -6,6 +7,7 @@ import {ColumnIndex, fulu} 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";
 import {
   handleColumnSidecarUnavailability,
   validateRequestedDataColumns,
@@ -14,7 +16,9 @@ import {
 export async function* onDataColumnSidecarsByRange(
   request: fulu.DataColumnSidecarsByRangeRequest,
   chain: IBeaconChain,
-  db: IBeaconDb
+  db: IBeaconDb,
+  peerId: PeerId,
+  peerClient: string
 ): AsyncIterable<ResponseOutgoing> {
   // Non-finalized range of columns
   const {startSlot, count, columns: requestedColumns} = validateDataColumnSidecarsByRangeRequest(chain.config, request);
@@ -25,6 +29,14 @@ export async function* onDataColumnSidecarsByRange(
     return;
   }
 
+  if (startSlot < chain.earliestAvailableSlot) {
+    chain.logger.verbose("Peer did not respect earliestAvailableSlot for DataColumnSidecarsByRange", {
+      peer: prettyPrintPeerId(peerId),
+      client: peerClient,
+    });
+    return;
+  }
+
   const finalized = db.dataColumnSidecarArchive;
   const unfinalized = db.dataColumnSidecar;
   const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;

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

@@ -1,3 +1,4 @@
+import {PeerId} from "@libp2p/interface";
 import {ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {ColumnIndex} from "@lodestar/types";
@@ -5,6 +6,7 @@ import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
 import {DataColumnSidecarsByRootRequest} from "../../../util/types.js";
+import {prettyPrintPeerId} from "../../util.ts";
 import {
   handleColumnSidecarUnavailability,
   validateRequestedDataColumns,
@@ -13,7 +15,9 @@ import {
 export async function* onDataColumnSidecarsByRoot(
   requestBody: DataColumnSidecarsByRootRequest,
   chain: IBeaconChain,
-  db: IBeaconDb
+  db: IBeaconDb,
+  peerId: PeerId,
+  peerClient: string
 ): AsyncIterable<ResponseOutgoing> {
   // SPEC: minimum_request_epoch = max(current_epoch - MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS, FULU_FORK_EPOCH)
   const currentEpoch = chain.clock.currentEpoch;
@@ -39,6 +43,14 @@ export async function* onDataColumnSidecarsByRoot(
       continue;
     }
 
+    if (slot < chain.earliestAvailableSlot) {
+      chain.logger.verbose("Peer did not respect earliestAvailableSlot for DataColumnSidecarsByRoot", {
+        peer: prettyPrintPeerId(peerId),
+        client: peerClient,
+      });
+      continue;
+    }
+
     const requestedEpoch = computeEpochAtSlot(slot);
 
     // SPEC: Clients MUST support requesting sidecars since minimum_request_epoch.

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

@@ -35,9 +35,9 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
     [ReqRespMethod.Goodbye]: notImplemented(ReqRespMethod.Goodbye),
     [ReqRespMethod.Ping]: notImplemented(ReqRespMethod.Ping),
     [ReqRespMethod.Metadata]: notImplemented(ReqRespMethod.Metadata),
-    [ReqRespMethod.BeaconBlocksByRange]: (req) => {
+    [ReqRespMethod.BeaconBlocksByRange]: (req, peerId, peerClient) => {
       const body = ssz.phase0.BeaconBlocksByRangeRequest.deserialize(req.data);
-      return onBeaconBlocksByRange(body, chain, db);
+      return onBeaconBlocksByRange(body, chain, db, peerId, peerClient);
     },
     [ReqRespMethod.BeaconBlocksByRoot]: (req) => {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
@@ -53,13 +53,13 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
       const body = ssz.deneb.BlobSidecarsByRangeRequest.deserialize(req.data);
       return onBlobSidecarsByRange(body, chain, db);
     },
-    [ReqRespMethod.DataColumnSidecarsByRange]: (req) => {
+    [ReqRespMethod.DataColumnSidecarsByRange]: (req, peerId, peerClient) => {
       const body = ssz.fulu.DataColumnSidecarsByRangeRequest.deserialize(req.data);
-      return onDataColumnSidecarsByRange(body, chain, db);
+      return onDataColumnSidecarsByRange(body, chain, db, peerId, peerClient);
     },
-    [ReqRespMethod.DataColumnSidecarsByRoot]: (req) => {
+    [ReqRespMethod.DataColumnSidecarsByRoot]: (req, peerId, peerClient) => {
       const body = DataColumnSidecarsByRootRequestType(chain.config).deserialize(req.data);
-      return onDataColumnSidecarsByRoot(body, chain, db);
+      return onDataColumnSidecarsByRoot(body, chain, db, peerId, peerClient);
     },
 
     [ReqRespMethod.LightClientBootstrap]: (req) => {

package/src/network/reqresp/types.ts

@@ -169,6 +169,7 @@ export type IncomingRequestArgs = {
   method: ReqRespMethod;
   req: ReqRespRequest;
   peerId: string;
+  peerClient: string;
 };
 
 export type GetReqRespHandlerFn = (method: ReqRespMethod) => ProtocolHandler;

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(","),