@lodestar/beacon-node 1.41.0-dev.253ed58dd1 → 1.41.0-dev.26ed5ad353

package/src/network/peers/discover.ts

@@ -59,6 +59,7 @@ export enum DiscoveredPeerStatus {
   cached = "cached",
   dropped = "dropped",
   no_multiaddrs = "no_multiaddrs",
+  transport_incompatible = "transport_incompatible",
   peer_cooling_down = "peer_cooling_down",
 }
 
@@ -88,7 +89,8 @@ export type SubnetDiscvQueryMs = {
 
 type CachedENR = {
   peerId: PeerId;
-  multiaddrTCP: Multiaddr;
+  multiaddrTCP?: Multiaddr;
+  multiaddrQUIC?: Multiaddr;
   subnets: Record<SubnetType, boolean[]>;
   addedUnixMs: number;
   // custodyGroups is null for pre-fulu
@@ -114,6 +116,7 @@ export class PeerDiscovery {
     attnets: new Map(),
     syncnets: new Map(),
   };
+  private transports: string[];
 
   private custodyGroupQueries: CustodyGroupQueries;
 
@@ -180,6 +183,17 @@ export class PeerDiscovery {
         }
       });
     }
+
+    // Transport tags vary by library: @libp2p/tcp uses '@libp2p/tcp', @chainsafe/libp2p-quic uses 'quic'
+    // Normalize to simple 'tcp' / 'quic' strings for matching
+    this.transports = libp2p.services.components.transportManager
+      .getTransports()
+      .map((t) => t[Symbol.toStringTag])
+      .map((tag) => {
+        if (tag?.includes("tcp")) return "tcp";
+        if (tag?.includes("quic")) return "quic";
+        return tag;
+      });
   }
 
   static async init(modules: PeerDiscoveryModules, opts: PeerDiscoveryOpts): Promise<PeerDiscovery> {
@@ -372,10 +386,15 @@ export class PeerDiscovery {
       return;
     }
 
+    // Select multiaddrs by protocol rather than index — libp2p discovery events
+    // don't guarantee ordering or number of addresses
+    const multiaddrTCP = multiaddrs.find((ma) => ma.toString().includes("/tcp/"));
+    const multiaddrQUIC = multiaddrs.find((ma) => ma.toString().includes("/quic-v1"));
+
     const attnets = zeroAttnets;
     const syncnets = zeroSyncnets;
 
-    const status = this.handleDiscoveredPeer(id, multiaddrs[0], attnets, syncnets, undefined);
+    const status = this.handleDiscoveredPeer(id, multiaddrTCP, multiaddrQUIC, attnets, syncnets, undefined);
     this.logger.debug("Discovered peer via libp2p", {peer: prettyPrintPeerId(id), status});
     this.metrics?.discovery.discoveredStatus.inc({status});
   };
@@ -388,13 +407,15 @@ export class PeerDiscovery {
       this.randomNodeQuery.count++;
     }
     const peerId = enr.peerId;
-    // tcp multiaddr is known to be be present, checked inside the worker
+    // At least one transport is known to be present, checked inside the worker
     const multiaddrTCP = enr.getLocationMultiaddr(ENRKey.tcp);
-    if (!multiaddrTCP) {
-      this.logger.warn("Discv5 worker sent enr without tcp multiaddr", {enr: enr.encodeTxt()});
+    const multiaddrQUIC = enr.getLocationMultiaddr(ENRKey.quic);
+    if (!multiaddrTCP && !multiaddrQUIC) {
+      this.logger.warn("Discv5 worker sent enr without any transport multiaddr", {enr: enr.encodeTxt()});
       this.metrics?.discovery.discoveredStatus.inc({status: DiscoveredPeerStatus.no_multiaddrs});
       return;
     }
+
     // Are this fields mandatory?
     const attnetsBytes = enr.kvs.get(ENRKey.attnets); // 64 bits
     const syncnetsBytes = enr.kvs.get(ENRKey.syncnets); // 4 bits
@@ -414,7 +435,7 @@ export class PeerDiscovery {
     const syncnets = syncnetsBytes ? deserializeEnrSubnets(syncnetsBytes, SYNC_COMMITTEE_SUBNET_COUNT) : zeroSyncnets;
     const custodyGroupCount = custodyGroupCountBytes ? bytesToInt(custodyGroupCountBytes, "be") : undefined;
 
-    const status = this.handleDiscoveredPeer(peerId, multiaddrTCP, attnets, syncnets, custodyGroupCount);
+    const status = this.handleDiscoveredPeer(peerId, multiaddrTCP, multiaddrQUIC, attnets, syncnets, custodyGroupCount);
     this.logger.debug("Discovered peer via discv5", {
       peer: prettyPrintPeerId(peerId),
       status,
@@ -428,7 +449,8 @@ export class PeerDiscovery {
    */
   private handleDiscoveredPeer(
     peerId: PeerId,
-    multiaddrTCP: Multiaddr,
+    multiaddrTCP: Multiaddr | undefined,
+    multiaddrQUIC: Multiaddr | undefined,
     attnets: boolean[],
     syncnets: boolean[],
     custodySubnetCount?: number
@@ -454,6 +476,13 @@ export class PeerDiscovery {
         return DiscoveredPeerStatus.already_connected;
       }
 
+      // ignore peers if they don't share any transport with us
+      const hasTcpMatch = this.transports.includes("tcp") && multiaddrTCP;
+      const hasQuicMatch = this.transports.includes("quic") && multiaddrQUIC;
+      if (!hasTcpMatch && !hasQuicMatch) {
+        return DiscoveredPeerStatus.transport_incompatible;
+      }
+
       // Ignore dialing peers
       if (
         this.libp2p.services.components.connectionManager
@@ -469,6 +498,7 @@ export class PeerDiscovery {
       const cachedPeer: CachedENR = {
         peerId,
         multiaddrTCP,
+        multiaddrQUIC,
         subnets: {attnets, syncnets},
         addedUnixMs: Date.now(),
         // for pre-fulu, custodyGroups is null
@@ -566,19 +596,24 @@ export class PeerDiscovery {
     // are not successful.
     this.peersToConnect = Math.max(this.peersToConnect - 1, 0);
 
-    const {peerId, multiaddrTCP} = cachedPeer;
+    const {peerId, multiaddrTCP, multiaddrQUIC} = cachedPeer;
 
     // Must add the multiaddrs array to the address book before dialing
     // https://github.com/libp2p/js-libp2p/blob/aec8e3d3bb1b245051b60c2a890550d262d5b062/src/index.js#L638
-    const peer = await this.libp2p.peerStore.merge(peerId, {multiaddrs: [multiaddrTCP]});
+    const peer = await this.libp2p.peerStore.merge(peerId, {
+      multiaddrs: [multiaddrQUIC, multiaddrTCP].filter(Boolean) as Multiaddr[],
+    });
     if (peer.addresses.length === 0) {
       this.metrics?.discovery.notDialReason.inc({reason: NotDialReason.no_multiaddrs});
       return;
     }
 
-    // Note: PeerDiscovery adds the multiaddrTCP beforehand
+    // Note: PeerDiscovery adds the multiaddrs beforehand
     const peerIdShort = prettyPrintPeerId(peerId);
-    this.logger.debug("Dialing discovered peer", {peer: peerIdShort});
+    this.logger.debug("Dialing discovered peer", {
+      peer: peerIdShort,
+      addresses: peer.addresses.map((a) => a.multiaddr.toString()).join(", "),
+    });
 
     this.metrics?.discovery.dialAttempts.inc();
     const timer = this.metrics?.discovery.dialTime.startTimer();

package/src/network/peers/peerManager.ts

@@ -9,6 +9,7 @@ import {prettyPrintIndices, toHex, withTimeout} from "@lodestar/utils";
 import {GOODBYE_KNOWN_CODES, GoodByeReasonCode, Libp2pEvent} from "../../constants/index.js";
 import {IClock} from "../../util/clock.js";
 import {computeColumnsForCustodyGroup, getCustodyGroups} from "../../util/dataColumns.js";
+import {callInNextEventLoop} from "../../util/eventLoop.js";
 import {NetworkCoreMetrics} from "../core/metrics.js";
 import {LodestarDiscv5Opts} from "../discv5/types.js";
 import {INetworkEventBus, NetworkEvent, NetworkEventData} from "../events.js";
@@ -161,7 +162,6 @@ export class PeerManager {
 
   // A single map of connected peers with all necessary data to handle PINGs, STATUS, and metrics
   private connectedPeers: Map<PeerIdStr, PeerData>;
-
   private opts: PeerManagerOpts;
   private intervals: NodeJS.Timeout[] = [];
 
@@ -196,6 +196,13 @@ export class PeerManager {
 
     this.lastStatus = this.statusCache.get();
 
+    // A connection may already be open before listeners are attached.
+    // Seed those peers so they are tracked in connectedPeers immediately.
+    this.bootstrapAlreadyOpenConnections();
+    // Defer status/ping to the next event loop tick so the heartbeat interval and
+    // event listeners are fully registered before we begin handshakes.
+    callInNextEventLoop(() => this.pingAndStatusTimeouts());
+
     // On start-up will connected to existing peers in libp2p.peerStore, same as autoDial behaviour
     this.heartbeat();
     this.intervals = [
@@ -472,6 +479,14 @@ export class PeerManager {
         clientAgent,
         custodyColumns,
       });
+
+      // Identify peer after status proves the connection is usable.
+      // This is the only place we trigger identify — avoids wasted streams on
+      // peers that close identify right after connection open or turn out to be
+      // irrelevant.
+      if (peerData?.agentVersion === null) {
+        void this.identifyPeer(peer.toString(), prettyPrintPeerId(peer), getConnection(this.libp2p, peer.toString()));
+      }
     }
   }
 
@@ -692,36 +707,39 @@ export class PeerManager {
     }
   }
 
-  /**
-   * The libp2p Upgrader has successfully upgraded a peer connection on a particular multiaddress
-   * This event is routed through the connectionManager
-   *
-   * Registers a peer as connected. The `direction` parameter determines if the peer is being
-   * dialed or connecting to us.
-   */
-  private onLibp2pPeerConnect = async (evt: CustomEvent<Connection>): Promise<void> => {
-    const {direction, status, remotePeer} = evt.detail;
+  private bootstrapAlreadyOpenConnections(): void {
+    let bootstrapped = 0;
+
+    for (const {value: connections} of getConnectionsMap(this.libp2p).values()) {
+      for (const connection of connections) {
+        // trackLibp2pConnection handles deduplication via overwriteExisting: false
+        if (this.trackLibp2pConnection(connection, {overwriteExisting: false, triggerHandshakeNow: false})) {
+          bootstrapped++;
+        }
+      }
+    }
+
+    if (bootstrapped > 0) {
+      this.logger.verbose("Bootstrapped already-open libp2p peers", {bootstrapped});
+    }
+  }
+
+  private trackLibp2pConnection(
+    connection: Connection,
+    opts: {overwriteExisting: boolean; triggerHandshakeNow: boolean}
+  ): boolean {
+    const {direction, status, remotePeer} = connection;
     const remotePeerStr = remotePeer.toString();
     const remotePeerPrettyStr = prettyPrintPeerId(remotePeer);
-    this.logger.verbose("peer connected", {peer: remotePeerPrettyStr, direction, status});
-    // NOTE: The peerConnect event is not emitted here here, but after asserting peer relevance
-    this.metrics?.peerConnectedEvent.inc({direction, status});
 
-    if (evt.detail.status !== "open") {
+    if (status !== "open") {
       this.logger.debug("Peer disconnected before identify protocol initiated", {
         peerId: remotePeerPrettyStr,
-        status: evt.detail.status,
+        status,
       });
-      return;
+      return false;
     }
 
-    // On connection:
-    // - Outbound connections: send a STATUS and PING request
-    // - Inbound connections: expect to be STATUS'd, schedule STATUS and PING for latter
-    // NOTE: libp2p may emit two "peer:connect" events: One for inbound, one for outbound
-    // If that happens, it's okay. Only the "outbound" connection triggers immediate action
-    const now = Date.now();
-
     // Ethereum uses secp256k1 for node IDs, reject peers with other key types
     if (remotePeer.type !== "secp256k1") {
       this.logger.debug("Peer does not have secp256k1 key, disconnecting", {
@@ -729,52 +747,64 @@ export class PeerManager {
         type: remotePeer.type,
       });
       void this.goodbyeAndDisconnect(remotePeer, GoodByeReasonCode.IRRELEVANT_NETWORK);
-      return;
+      return false;
     }
 
+    if (!opts.overwriteExisting && this.connectedPeers.has(remotePeerStr)) {
+      return false;
+    }
+
+    // On connection:
+    // - Outbound connections: send a STATUS and PING request
+    // - Inbound connections: expect to be STATUS'd, schedule STATUS and PING for later
+    // NOTE: libp2p may emit two "peer:connect" events: One for inbound, one for outbound
+    // If that happens, it's okay. Only the "outbound" connection triggers immediate action
+    const now = Date.now();
+    const existingPeerData = this.connectedPeers.get(remotePeerStr);
     const nodeId = computeNodeId(remotePeer);
     const peerData: PeerData = {
-      lastReceivedMsgUnixTsMs: direction === "outbound" ? 0 : now,
+      // Keep existing timestamps if this peer already had another open connection.
+      // libp2p may emit multiple connection:open events per peer.
+      lastReceivedMsgUnixTsMs: existingPeerData?.lastReceivedMsgUnixTsMs ?? (direction === "outbound" ? 0 : now),
       // If inbound, request after STATUS_INBOUND_GRACE_PERIOD
-      lastStatusUnixTsMs: direction === "outbound" ? 0 : now - STATUS_INTERVAL_MS + STATUS_INBOUND_GRACE_PERIOD,
-      connectedUnixTsMs: now,
-      relevantStatus: RelevantPeerStatus.Unknown,
+      lastStatusUnixTsMs:
+        existingPeerData?.lastStatusUnixTsMs ??
+        (direction === "outbound" ? 0 : now - STATUS_INTERVAL_MS + STATUS_INBOUND_GRACE_PERIOD),
+      connectedUnixTsMs: existingPeerData?.connectedUnixTsMs ?? now,
+      relevantStatus: existingPeerData?.relevantStatus ?? RelevantPeerStatus.Unknown,
       direction,
       nodeId,
       peerId: remotePeer,
-      status: null,
-      metadata: null,
-      agentVersion: null,
-      agentClient: null,
-      encodingPreference: null,
+      status: existingPeerData?.status ?? null,
+      metadata: existingPeerData?.metadata ?? null,
+      agentVersion: existingPeerData?.agentVersion ?? null,
+      agentClient: existingPeerData?.agentClient ?? null,
+      encodingPreference: existingPeerData?.encodingPreference ?? null,
     };
     this.connectedPeers.set(remotePeerStr, peerData);
 
-    if (direction === "outbound") {
-      // this.pingAndStatusTimeouts();
+    if (direction === "outbound" && opts.triggerHandshakeNow) {
       void this.requestPing(remotePeer);
       void this.requestStatus(remotePeer, this.statusCache.get());
     }
 
-    this.libp2p.services.identify
-      .identify(evt.detail)
-      .then((result) => {
-        const agentVersion = result.agentVersion;
-        if (agentVersion) {
-          peerData.agentVersion = agentVersion;
-          peerData.agentClient = getKnownClientFromAgentVersion(agentVersion);
-        }
-      })
-      .catch((err) => {
-        if (evt.detail.status !== "open") {
-          this.logger.debug("Peer disconnected during identify protocol", {
-            peerId: remotePeerPrettyStr,
-            error: (err as Error).message,
-          });
-        } else {
-          this.logger.debug("Error setting agentVersion for the peer", {peerId: remotePeerPrettyStr}, err);
-        }
-      });
+    return true;
+  }
+
+  /**
+   * The libp2p Upgrader has successfully upgraded a peer connection on a particular multiaddress
+   * This event is routed through the connectionManager
+   *
+   * Registers a peer as connected. The `direction` parameter determines if the peer is being
+   * dialed or connecting to us.
+   */
+  private onLibp2pPeerConnect = (evt: CustomEvent<Connection>): void => {
+    const {direction, status, remotePeer} = evt.detail;
+    this.logger.verbose("peer connected", {peer: prettyPrintPeerId(remotePeer), direction, status});
+    // NOTE: The peerConnect event is not emitted here here, but after asserting peer relevance
+    this.metrics?.peerConnectedEvent.inc({direction, status});
+
+    this.trackLibp2pConnection(evt.detail, {overwriteExisting: true, triggerHandshakeNow: true});
   };
 
   /**
@@ -784,6 +814,19 @@ export class PeerManager {
     const {direction, status, remotePeer} = evt.detail;
     const peerIdStr = remotePeer.toString();
 
+    const openConnections =
+      getConnectionsMap(this.libp2p)
+        .get(peerIdStr)
+        ?.value.filter((connection) => connection.status === "open") ?? [];
+    if (openConnections.length > 0) {
+      this.logger.debug("Ignoring peer disconnect event while another connection is still open", {
+        peerId: prettyPrintPeerIdStr(peerIdStr),
+        direction,
+        status,
+      });
+      return;
+    }
+
     let logMessage = "onLibp2pPeerDisconnect";
     const logContext: Record<string, string | number> = {
       peerId: prettyPrintPeerIdStr(peerIdStr),
@@ -818,6 +861,27 @@ export class PeerManager {
     }
   }
 
+  private async identifyPeer(peerIdStr: string, peerIdPretty: string, connection?: Connection): Promise<void> {
+    if (!connection || connection.status !== "open") {
+      this.logger.debug("Peer has no open connection for identify", {peerId: peerIdPretty});
+      return;
+    }
+
+    try {
+      const result = await this.libp2p.services.identify.identify(connection);
+      const agentVersion = result.agentVersion;
+      if (agentVersion) {
+        const connectedPeerData = this.connectedPeers.get(peerIdStr);
+        if (connectedPeerData) {
+          connectedPeerData.agentVersion = agentVersion;
+          connectedPeerData.agentClient = getKnownClientFromAgentVersion(agentVersion);
+        }
+      }
+    } catch (e) {
+      this.logger.debug("Error setting agentVersion for the peer", {peerId: peerIdPretty}, e as Error);
+    }
+  }
+
   private async goodbyeAndDisconnect(peer: PeerId, goodbye: GoodByeReasonCode): Promise<void> {
     const reason = GOODBYE_KNOWN_CODES[goodbye.toString()] || "";
     const peerIdStr = peer.toString();

package/src/network/peers/utils/prioritizePeers.ts

@@ -1,4 +1,4 @@
-import {Direction, PeerId} from "@libp2p/interface";
+import type {MessageStreamDirection, PeerId} from "@libp2p/interface";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainConfig} from "@lodestar/config";
 import {ATTESTATION_SUBNET_COUNT, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
@@ -95,7 +95,7 @@ function computeStatusScore(ours: Status, theirs: Status | null, opts: Prioritiz
 
 type PeerInfo = {
   id: PeerId;
-  direction: Direction | null;
+  direction: MessageStreamDirection | null;
   statusScore: StatusScore;
   attnets: phase0.AttestationSubnets;
   syncnets: altair.SyncSubnets;
@@ -137,7 +137,7 @@ export enum ExcessPeerDisconnectReason {
 export function prioritizePeers(
   connectedPeersInfo: {
     id: PeerId;
-    direction: Direction | null;
+    direction: MessageStreamDirection | null;
     status: Status | null;
     attnets: phase0.AttestationSubnets | null;
     syncnets: altair.SyncSubnets | null;

package/src/network/processor/gossipHandlers.ts

@@ -2,6 +2,7 @@ import {routes} from "@lodestar/api";
 import {BeaconConfig, ChainForkConfig} from "@lodestar/config";
 import {
   ForkName,
+  ForkPostDeneb,
   ForkPostElectra,
   ForkPreElectra,
   ForkSeq,
@@ -70,6 +71,7 @@ import {validateGossipPayloadAttestationMessage} from "../../chain/validation/pa
 import {OpSource} from "../../chain/validatorMonitor.js";
 import {Metrics} from "../../metrics/index.js";
 import {kzgCommitmentToVersionedHash} from "../../util/blobs.js";
+import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {INetworkCore} from "../core/index.js";
 import {NetworkEventBus} from "../events.js";
 import {
@@ -417,9 +419,11 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       chain.getBlobsTracker.triggerGetBlobs(blockInput);
     } else {
       metrics?.blockInputFetchStats.totalDataAvailableBlockInputs.inc();
-      metrics?.blockInputFetchStats.totalDataAvailableBlockInputBlobs.inc(
-        (signedBlock.message as deneb.BeaconBlock).body.blobKzgCommitments.length
-      );
+      const blobCount = getBlobKzgCommitments(
+        blockInput.forkName,
+        signedBlock as SignedBeaconBlock<ForkPostDeneb>
+      ).length;
+      metrics?.blockInputFetchStats.totalDataAvailableBlockInputBlobs.inc(blobCount);
     }
 
     chain
@@ -852,6 +856,11 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       } catch (e) {
         logger.error("Error adding to payloadAttestation pool", {}, e as Error);
       }
+      chain.forkChoice.notifyPtcMessages(
+        toRootHex(payloadAttestationMessage.data.beaconBlockRoot),
+        [validationResult.validatorCommitteeIndex],
+        payloadAttestationMessage.data.payloadPresent
+      );
     },
     [GossipType.execution_payload_bid]: async ({
       gossipData,

package/src/network/processor/gossipValidatorFn.ts

@@ -1,4 +1,4 @@
-import {TopicValidatorResult} from "@libp2p/interface";
+import {TopicValidatorResult} from "@libp2p/gossipsub";
 import {ChainForkConfig} from "@lodestar/config";
 import {Logger} from "@lodestar/utils";
 import {AttestationError, GossipAction, GossipActionError} from "../../chain/errors/index.js";
@@ -11,7 +11,7 @@ import {
   GossipValidatorBatchFn,
   GossipValidatorFn,
 } from "../gossip/interface.js";
-import {prettyPrintPeerIdStr} from "../util.ts";
+import {prettyPrintPeerIdStr} from "../util.js";
 
 export type ValidatorFnModules = {
   config: ChainForkConfig;

package/src/network/processor/types.ts

@@ -1,4 +1,4 @@
-import {Message} from "@libp2p/interface";
+import type {Message} from "@libp2p/gossipsub";
 import {ForkName} from "@lodestar/params";
 import {Slot, SlotOptionalRoot} from "@lodestar/types";
 import {PeerIdStr} from "../../util/peerId.js";

package/src/network/reqresp/ReqRespBeaconNode.ts

@@ -19,7 +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 {ClientKind} from "../peers/client.js";
 import {PeersData} from "../peers/peersData.js";
 import {IPeerRpcScoreStore, PeerAction} from "../peers/score/index.js";
 import {StatusCache} from "../statusCache.js";

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

@@ -6,7 +6,7 @@ import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {deneb, phase0} from "@lodestar/types";
 import {IBeaconChain} from "../../../chain/index.js";
 import {IBeaconDb} from "../../../db/index.js";
-import {prettyPrintPeerId} from "../../util.ts";
+import {prettyPrintPeerId} from "../../util.js";
 
 // TODO: Unit test
 
@@ -47,9 +47,10 @@ export async function* onBeaconBlocksByRange(
 
   // Non-finalized range of blocks
   if (endSlot > finalizedSlot) {
-    const headRoot = chain.forkChoice.getHeadRoot();
+    const headBlock = chain.forkChoice.getHead();
+    const headRoot = headBlock.blockRoot;
     // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
-    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
     // getAllAncestorBlocks response includes the head node, so it's the full chain.
 
     // Iterate head chain with ascending block numbers

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

@@ -34,9 +34,10 @@ export async function* onBlobSidecarsByRange(
 
   // Non-finalized range of blobs
   if (endSlot > finalizedSlot) {
-    const headRoot = chain.forkChoice.getHeadRoot();
+    const headBlock = chain.forkChoice.getHead();
+    const headRoot = headBlock.blockRoot;
     // TODO DENEB: forkChoice should mantain an array of canonical blocks, and change only on reorg
-    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
 
     // Iterate head chain with ascending block numbers
     for (let i = headChain.length - 1; i >= 0; i--) {

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

@@ -20,7 +20,7 @@ export async function* onBlobSidecarsByRoot(
   for (const blobIdentifier of requestBody) {
     const {blockRoot, index} = blobIdentifier;
     const blockRootHex = toRootHex(blockRoot);
-    const block = chain.forkChoice.getBlockHex(blockRootHex);
+    const block = chain.forkChoice.getBlockHexDefaultStatus(blockRootHex);
 
     // NOTE: Only support non-finalized blocks.
     // SPEC: Clients MUST support requesting blocks and sidecars since the latest finalized epoch.

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

@@ -7,7 +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 {prettyPrintPeerId} from "../../util.js";
 import {
   handleColumnSidecarUnavailability,
   validateRequestedDataColumns,
@@ -78,8 +78,9 @@ export async function* onDataColumnSidecarsByRange(
 
   // Non-finalized range of columns
   if (endSlot > finalizedSlot) {
-    const headRoot = chain.forkChoice.getHeadRoot();
-    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot);
+    const headBlock = chain.forkChoice.getHead();
+    const headRoot = headBlock.blockRoot;
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
 
     // Iterate head chain with ascending block numbers
     for (let i = headChain.length - 1; i >= 0; i--) {

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

@@ -6,7 +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 {prettyPrintPeerId} from "../../util.js";
 import {
   handleColumnSidecarUnavailability,
   validateRequestedDataColumns,
@@ -34,7 +34,7 @@ export async function* onDataColumnSidecarsByRoot(
     }
 
     const blockRootHex = toRootHex(blockRoot);
-    const block = chain.forkChoice.getBlockHex(blockRootHex);
+    const block = chain.forkChoice.getBlockHexDefaultStatus(blockRootHex);
     // If the block is not in fork choice, it may be finalized. Attempt to find its slot in block archive
     const slot = block ? block.slot : await db.blockArchive.getSlotByRoot(blockRoot);
 

package/src/network/reqresp/score.ts

@@ -38,7 +38,6 @@ export function onOutgoingReqRespError(e: RequestError, method: ReqRespMethod):
         : PeerAction.LowToleranceError;
     // TODO: Detect SSZDecodeError and return PeerAction.Fatal
 
-    case RequestErrorCode.TTFB_TIMEOUT:
     case RequestErrorCode.RESP_TIMEOUT:
       switch (method) {
         case ReqRespMethod.Ping:

package/src/network/reqresp/utils/collect.ts

@@ -1,6 +1,6 @@
 import {Type} from "@chainsafe/ssz";
 import {RequestError, RequestErrorCode, ResponseIncoming} from "@lodestar/reqresp";
-import {SerializedCache} from "../../../util/serializedCache.ts";
+import {SerializedCache} from "../../../util/serializedCache.js";
 import {ResponseTypeGetter} from "../types.js";
 
 /**

package/src/network/reqresp/utils/collectSequentialBlocksInRange.ts

@@ -1,7 +1,7 @@
 import {ResponseIncoming} from "@lodestar/reqresp";
 import {SignedBeaconBlock, phase0} from "@lodestar/types";
 import {LodestarError} from "@lodestar/utils";
-import {SerializedCache} from "../../../util/serializedCache.ts";
+import {SerializedCache} from "../../../util/serializedCache.js";
 import {ReqRespMethod, responseSszTypeByMethod} from "../types.js";
 import {sszDeserializeResponse} from "./collect.js";
 

package/src/network/util.ts

@@ -23,7 +23,7 @@ export function getConnection(libp2p: Libp2p, peerIdStr: string): Connection | u
   return getConnectionsMap(libp2p).get(peerIdStr)?.value[0] ?? undefined;
 }
 
-// https://github.com/ChainSafe/js-libp2p-gossipsub/blob/3475242ed254f7647798ab7f36b21909f6cb61da/src/index.ts#L2009
+// https://github.com/libp2p/js-libp2p/blob/f87cba928991736d9646b3e054c367f55cab315c/packages/gossipsub/src/gossipsub.ts#L2076
 export function isPublishToZeroPeersError(e: Error): boolean {
-  return e.message.includes("PublishError.InsufficientPeers");
+  return e.message.includes("PublishError.NoPeersSubscribedToTopic");
 }