@lodestar/beacon-node 1.41.0-dev.555261016d → 1.41.0-dev.6eb55025ce

package/src/network/network.ts

@@ -1,7 +1,7 @@
-import {PeerId, PrivateKey} from "@libp2p/interface";
+import type {PeerScoreStatsDump} from "@libp2p/gossipsub/score";
+import type {PublishOpts} from "@libp2p/gossipsub/types";
+import type {PeerId, PrivateKey} from "@libp2p/interface";
 import {peerIdFromPrivateKey} from "@libp2p/peer-id";
-import {PeerScoreStatsDump} from "@chainsafe/libp2p-gossipsub/score";
-import {PublishOpts} from "@chainsafe/libp2p-gossipsub/types";
 import {routes} from "@lodestar/api";
 import {BeaconConfig} from "@lodestar/config";
 import {LoggerNode} from "@lodestar/logger/node";
@@ -10,6 +10,8 @@ import {ResponseIncoming} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {
   AttesterSlashing,
+  DataColumnSidecar,
+  DataColumnSidecars,
   LightClientBootstrap,
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
@@ -24,6 +26,8 @@ import {
   capella,
   deneb,
   fulu,
+  gloas,
+  isGloasDataColumnSidecar,
   phase0,
 } from "@lodestar/types";
 import {prettyPrintIndices, sleep} from "@lodestar/utils";
@@ -354,8 +358,11 @@ export class Network implements INetwork {
     });
   }
 
-  async publishDataColumnSidecar(dataColumnSidecar: fulu.DataColumnSidecar): Promise<number> {
-    const epoch = computeEpochAtSlot(dataColumnSidecar.signedBlockHeader.message.slot);
+  async publishDataColumnSidecar(dataColumnSidecar: DataColumnSidecar): Promise<number> {
+    const slot = isGloasDataColumnSidecar(dataColumnSidecar)
+      ? dataColumnSidecar.slot
+      : dataColumnSidecar.signedBlockHeader.message.slot;
+    const epoch = computeEpochAtSlot(slot);
     const boundary = this.config.getForkBoundaryAtEpoch(epoch);
 
     const subnet = computeSubnetForDataColumnSidecar(this.config, dataColumnSidecar);
@@ -489,6 +496,17 @@ export class Network implements INetwork {
     );
   }
 
+  async publishSignedExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope): Promise<number> {
+    const epoch = computeEpochAtSlot(signedEnvelope.message.slot);
+    const boundary = this.config.getForkBoundaryAtEpoch(epoch);
+
+    return this.publishGossip<GossipType.execution_payload>(
+      {type: GossipType.execution_payload, boundary},
+      signedEnvelope,
+      {ignoreDuplicatePublishError: true}
+    );
+  }
+
   private async publishGossip<K extends GossipType>(
     topic: GossipTopicMap[K],
     object: GossipTypeMap[K],
@@ -765,7 +783,7 @@ export class Network implements INetwork {
     this.core.setTargetGroupCount(count);
   };
 
-  private onPublishDataColumns = (sidecars: fulu.DataColumnSidecar[]): Promise<number[]> => {
+  private onPublishDataColumns = (sidecars: DataColumnSidecars): Promise<number[]> => {
     return promiseAllMaybeAsync(sidecars.map((sidecar) => () => this.publishDataColumnSidecar(sidecar)));
   };
 

package/src/network/options.ts

@@ -72,4 +72,7 @@ export const defaultNetworkOptions: NetworkOptions = {
   //   - for fusaka-devnets, we have 25-30 peers per subnet
   //   - for public testnets or mainnet, average number of peers per group is SAMPLES_PER_SLOT * targetPeers / NUMBER_OF_CUSTODY_GROUPS = 6.25 so this should not be an issue
   targetGroupPeers: 6,
+  // Keep this high enough for normal req/resp bursts on stable connections.
+  // libp2p-mplex default (5) is too low and can cause frequent connection resets.
+  disconnectThreshold: 50,
 };

package/src/network/peers/datastore.ts

@@ -8,6 +8,9 @@ type MemoryItem = {
   data: Uint8Array;
 };
 
+// biome-ignore lint/suspicious/noExplicitAny: used below (copied from upstream)
+type AwaitGenerator<T, TReturn = any, TNext = any> = Generator<T, TReturn, TNext> | AsyncGenerator<T, TReturn, TNext>;
+
 /**
  * Before libp2p 0.35, peerstore stays in memory and periodically write to db after n dirty items
  * This has a memory issue because all peer data stays in memory and loaded at startup time
@@ -93,7 +96,7 @@ export class Eth2PeerDataStore extends BaseDatastore {
    * This throws error if not found
    * see https://github.com/ipfs/js-datastore-level/blob/38f44058dd6be858e757a1c90b8edb31590ec0bc/src/index.js#L102
    */
-  async get(key: Key): Promise<Uint8Array> {
+  async get(key: Key, options?: AbortOptions): Promise<Uint8Array> {
     const keyStr = key.toString();
     const memoryItem = this._memoryDatastore.get(keyStr);
     if (memoryItem) {
@@ -102,16 +105,16 @@ export class Eth2PeerDataStore extends BaseDatastore {
     }
 
     // this throws error if not found
-    const dbValue = await this._dbDatastore.get(key);
+    const dbValue = await this._dbDatastore.get(key, options);
     // don't call this._memoryDatastore.set directly
     // we want to get through prune() logic with fromDb as true
     await this._put(key, dbValue, true);
     return dbValue;
   }
 
-  async has(key: Key): Promise<boolean> {
+  async has(key: Key, options?: AbortOptions): Promise<boolean> {
     try {
-      await this.get(key);
+      await this.get(key, options);
     } catch (err) {
       // this is the same to how js-datastore-level handles notFound error
       // https://github.com/ipfs/js-datastore-level/blob/38f44058dd6be858e757a1c90b8edb31590ec0bc/src/index.js#L121
@@ -121,26 +124,26 @@ export class Eth2PeerDataStore extends BaseDatastore {
     return true;
   }
 
-  async delete(key: Key): Promise<void> {
+  async delete(key: Key, options?: AbortOptions): Promise<void> {
     this._memoryDatastore.delete(key.toString());
-    await this._dbDatastore.delete(key);
+    await this._dbDatastore.delete(key, options);
   }
 
-  async *_all(q: Query): AsyncIterable<Pair> {
+  async *_all(q: Query, options?: AbortOptions): AwaitGenerator<Pair> {
     for (const [key, value] of this._memoryDatastore.entries()) {
       yield {
         key: new Key(key),
         value: value.data,
       };
     }
-    yield* this._dbDatastore.query(q);
+    yield* this._dbDatastore.query(q, options);
   }
 
-  async *_allKeys(q: KeyQuery): AsyncIterable<Key> {
+  async *_allKeys(q: KeyQuery, options?: AbortOptions): AwaitGenerator<Key> {
     for (const key of this._memoryDatastore.keys()) {
       yield new Key(key);
     }
-    yield* this._dbDatastore.queryKeys(q);
+    yield* this._dbDatastore.queryKeys(q, options);
   }
 
   private async _addDirtyItem(keyStr: string): Promise<void> {

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

@@ -548,7 +548,8 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       seenTimestampSec,
     }: GossipHandlerParamGeneric<GossipType.data_column_sidecar>) => {
       const {serializedData} = gossipData;
-      const dataColumnSidecar = sszDeserialize(topic, serializedData);
+      // TODO GLOAS: handle gloas.DataColumnSidecar
+      const dataColumnSidecar = sszDeserialize(topic, serializedData) as fulu.DataColumnSidecar;
       const dataColumnSlot = dataColumnSidecar.signedBlockHeader.message.slot;
       const index = dataColumnSidecar.index;
 
@@ -821,11 +822,16 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     [GossipType.execution_payload]: async ({
       gossipData,
       topic,
+      seenTimestampSec,
     }: GossipHandlerParamGeneric<GossipType.execution_payload>) => {
       const {serializedData} = gossipData;
       const executionPayloadEnvelope = sszDeserialize(topic, serializedData);
       await validateGossipExecutionPayloadEnvelope(chain, executionPayloadEnvelope);
 
+      const slot = executionPayloadEnvelope.message.slot;
+      const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
+      metrics?.gossipExecutionPayloadEnvelope.elapsedTimeTillReceived.observe({source: OpSource.gossip}, delaySec);
+
       // TODO GLOAS: Handle valid envelope. Need an import flow that calls `processExecutionPayloadEnvelope` and fork choice
     },
     [GossipType.payload_attestation_message]: async ({

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";

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

@@ -19,6 +19,7 @@ export async function* onLightClientUpdatesByRange(
   assertLightClientServer(chain.lightClientServer);
 
   const count = Math.min(MAX_REQUEST_LIGHT_CLIENT_UPDATES, requestBody.count);
+  let started = false;
   for (let period = requestBody.startPeriod; period < requestBody.startPeriod + count; period++) {
     try {
       const update = await chain.lightClientServer.getUpdate(period);
@@ -29,9 +30,13 @@ export async function* onLightClientUpdatesByRange(
         data: type.serialize(update),
         boundary,
       };
+      started = true;
     } catch (e) {
       if ((e as LightClientServerError).type?.code === LightClientServerErrorCode.RESOURCE_UNAVAILABLE) {
-        throw new ResponseError(RespStatus.RESOURCE_UNAVAILABLE, (e as Error).message);
+        // Period not available, if we already started yielding, stop to
+        // preserve consecutive order. Otherwise skip leading gaps.
+        if (started) return;
+        continue;
       }
       throw new ResponseError(RespStatus.SERVER_ERROR, (e as Error).message);
     }

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/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");
 }

package/src/node/nodejs.ts

@@ -2,12 +2,11 @@ import {setMaxListeners} from "node:events";
 import {PrivateKey} from "@libp2p/interface";
 import {Registry} from "prom-client";
 import {hasher} from "@chainsafe/persistent-merkle-tree";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconApiMethods} from "@lodestar/api/beacon/server";
 import {BeaconConfig} from "@lodestar/config";
 import type {LoggerNode} from "@lodestar/logger/node";
 import {ZERO_HASH_HEX} from "@lodestar/params";
-import {CachedBeaconStateAllForks, Index2PubkeyCache, isExecutionCachedStateType} from "@lodestar/state-transition";
+import {CachedBeaconStateAllForks, PubkeyCache, isExecutionCachedStateType} from "@lodestar/state-transition";
 import {phase0} from "@lodestar/types";
 import {sleep, toRootHex} from "@lodestar/utils";
 import {ProcessShutdownCallback} from "@lodestar/validator";
@@ -47,8 +46,7 @@ export type BeaconNodeModules = {
 export type BeaconNodeInitModules = {
   opts: IBeaconNodeOptions;
   config: BeaconConfig;
-  pubkey2index: PubkeyIndexMap;
-  index2pubkey: Index2PubkeyCache;
+  pubkeyCache: PubkeyCache;
   db: IBeaconDb;
   logger: LoggerNode;
   processShutdownCallback: ProcessShutdownCallback;
@@ -150,8 +148,7 @@ export class BeaconNode {
   static async init<T extends BeaconNode = BeaconNode>({
     opts,
     config,
-    pubkey2index,
-    index2pubkey,
+    pubkeyCache,
     db,
     logger,
     processShutdownCallback,
@@ -240,8 +237,7 @@ export class BeaconNode {
       privateKey,
       config,
       clock,
-      pubkey2index,
-      index2pubkey,
+      pubkeyCache,
       dataDir,
       db,
       dbName: opts.db.name,
@@ -364,9 +360,12 @@ export class BeaconNode {
       if (this.restApi) await this.restApi.close();
       await this.network.close();
       if (this.metricsServer) await this.metricsServer.close();
-      if (this.monitoring) this.monitoring.close();
+      if (this.monitoring) await this.monitoring.close();
       await this.chain.persistToDisk();
       await this.chain.close();
+      // Abort signal last: close() calls above clear intervals/timeouts so no new
+      // operations get scheduled. If we aborted first, a still-pending interval could
+      // fire and schedule a new operation after abort, leaving it stuck and delaying shutdown.
       if (this.controller) this.controller.abort();
       await sleep(DELAY_BEFORE_CLOSING_DB_MS);
       await this.db.close();

package/src/sync/utils/downloadByRange.ts

@@ -1,12 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {
-  ForkPostDeneb,
-  ForkPostFulu,
-  ForkPreFulu,
-  ForkPreGloas,
-  isForkPostFulu,
-  isForkPostGloas,
-} from "@lodestar/params";
+import {ForkPostDeneb, ForkPostFulu, ForkPreFulu, isForkPostFulu} from "@lodestar/params";
 import {SignedBeaconBlock, Slot, deneb, fulu, phase0} from "@lodestar/types";
 import {LodestarError, Logger, byteArrayEquals, fromHex, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {
@@ -20,6 +13,7 @@ import {SeenBlockInput} from "../../chain/seenCache/seenGossipBlockInput.js";
 import {validateBlockBlobSidecars} from "../../chain/validation/blobSidecar.js";
 import {validateBlockDataColumnSidecars} from "../../chain/validation/dataColumnSidecar.js";
 import {INetwork} from "../../network/index.js";
+import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {PeerIdStr} from "../../util/peerId.js";
 import {WarnResult} from "../../util/wrapError.js";
 
@@ -695,13 +689,7 @@ export async function validateColumnsByRangeResponse(
         dataFork: dataSlot ? config.getForkName(dataSlot) : "unknown",
       });
     }
-    if (isForkPostGloas(forkName)) {
-      // TODO GLOAS: Post-gloas's blobKzgCommitments is not in beacon block body. Need to source it from somewhere else.
-      // if block without columns is passed default to zero and throw below
-      blobCount = 0;
-    } else {
-      blobCount = (block as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>).message.body.blobKzgCommitments.length;
-    }
+    blobCount = getBlobKzgCommitments(forkName, block as SignedBeaconBlock<ForkPostFulu>).length;
 
     if (columnSidecars.length === 0) {
       if (!blobCount) {

package/src/sync/utils/downloadByRoot.ts

@@ -1,14 +1,7 @@
 import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {
-  ForkPostDeneb,
-  ForkPostFulu,
-  ForkPreFulu,
-  ForkPreGloas,
-  isForkPostDeneb,
-  isForkPostFulu,
-} from "@lodestar/params";
-import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {ForkPostDeneb, ForkPostFulu, ForkPreFulu, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
 import {LodestarError, byteArrayEquals, fromHex, prettyPrintIndices, toHex, toRootHex} from "@lodestar/utils";
 import {isBlockInputBlobs, isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {BlockInputSource, IBlockInput} from "../../chain/blocks/blockInput/types.js";
@@ -19,6 +12,7 @@ import {validateBlockDataColumnSidecars} from "../../chain/validation/dataColumn
 import {INetwork} from "../../network/interface.js";
 import {PeerSyncMeta} from "../../network/peers/peersData.js";
 import {prettyPrintPeerIdStr} from "../../network/util.js";
+import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {PeerIdStr} from "../../util/peerId.js";
 import {WarnResult} from "../../util/wrapError.js";
 import {
@@ -378,14 +372,14 @@ export async function fetchAndValidateColumns({
   chain,
   network,
   peerMeta,
+  forkName,
   block,
   blockRoot,
   missing,
 }: FetchByRootAndValidateColumnsProps): Promise<WarnResult<fulu.DataColumnSidecars, DownloadByRootError>> {
   const {peerId: peerIdStr} = peerMeta;
   const slot = block.message.slot;
-  // TODO GLOAS: Get blob count from somewhere else since blobKzgCommitments is absent from block body
-  const blobCount = (block.message.body as BeaconBlockBody<ForkPostFulu & ForkPreGloas>).blobKzgCommitments.length;
+  const blobCount = getBlobKzgCommitments(forkName, block).length;
   if (blobCount === 0) {
     return {result: [], warnings: null};
   }