@lodestar/beacon-node 1.41.0-dev.e27085846c → 1.41.0-dev.ef310100c0

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";
@@ -196,6 +197,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 = [
@@ -692,36 +700,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,9 +740,19 @@ 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 nodeId = computeNodeId(remotePeer);
     const peerData: PeerData = {
       lastReceivedMsgUnixTsMs: direction === "outbound" ? 0 : now,
@@ -750,14 +771,13 @@ export class PeerManager {
     };
     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)
+      .identify(connection)
       .then((result) => {
         const agentVersion = result.agentVersion;
         if (agentVersion) {
@@ -766,7 +786,7 @@ export class PeerManager {
         }
       })
       .catch((err) => {
-        if (evt.detail.status !== "open") {
+        if (connection.status !== "open") {
           this.logger.debug("Peer disconnected during identify protocol", {
             peerId: remotePeerPrettyStr,
             error: (err as Error).message,
@@ -775,6 +795,24 @@ export class PeerManager {
           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});
   };
 
   /**

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/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/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/util/blobs.ts

@@ -13,7 +13,7 @@ import {
   VERSIONED_HASH_VERSION_KZG,
 } from "@lodestar/params";
 import {signedBlockToSignedHeader} from "@lodestar/state-transition";
-import {BeaconBlockBody, SSZTypesFor, SignedBeaconBlock, deneb, fulu, ssz} from "@lodestar/types";
+import {BeaconBlockBody, DataColumnSidecars, SSZTypesFor, SignedBeaconBlock, deneb, fulu, ssz} from "@lodestar/types";
 import {kzg} from "./kzg.js";
 
 type VersionHash = Uint8Array;
@@ -149,7 +149,7 @@ export async function dataColumnMatrixRecovery(
  * Reconstruct blobs from a set of data columns, at least 50%+ of all the columns
  * must be provided to allow to reconstruct the full data matrix
  */
-export async function reconstructBlobs(sidecars: fulu.DataColumnSidecars, indices?: number[]): Promise<deneb.Blobs> {
+export async function reconstructBlobs(sidecars: DataColumnSidecars, indices?: number[]): Promise<deneb.Blobs> {
   if (sidecars.length < NUMBER_OF_COLUMNS / 2) {
     throw Error(
       `Expected at least ${NUMBER_OF_COLUMNS / 2} data columns to reconstruct blobs, received ${sidecars.length}`
@@ -188,7 +188,7 @@ export async function reconstructBlobs(sidecars: fulu.DataColumnSidecars, indice
  * Recover cells for specific blob indices from a set of data columns
  */
 async function recoverBlobCells(
-  partialSidecars: fulu.DataColumnSidecar[],
+  partialSidecars: DataColumnSidecars,
   blobIndices: number[]
 ): Promise<Map<number, fulu.Cell[]> | null> {
   const columnCount = partialSidecars.length;

package/src/util/dataColumns.ts

@@ -4,6 +4,7 @@ import {ChainForkConfig} from "@lodestar/config";
 import {
   ForkAll,
   ForkName,
+  ForkPostDeneb,
   ForkPostFulu,
   ForkPreGloas,
   KZG_COMMITMENTS_GINDEX,
@@ -15,9 +16,11 @@ import {
   BeaconBlockBody,
   ColumnIndex,
   CustodyIndex,
+  Root,
   SSZTypesFor,
   SignedBeaconBlock,
   SignedBeaconBlockHeader,
+  Slot,
   deneb,
   fulu,
   gloas,
@@ -269,7 +272,7 @@ export async function getCellsAndProofs(
  */
 export function getBlobKzgCommitments(
   fork: ForkName,
-  signedBlock: SignedBeaconBlock<ForkPostFulu>
+  signedBlock: SignedBeaconBlock<ForkPostDeneb>
 ): deneb.KZGCommitment[] {
   if (isForkPostGloas(fork)) {
     return (signedBlock as gloas.SignedBeaconBlock).message.body.signedExecutionPayloadBid.message.blobKzgCommitments;
@@ -359,6 +362,39 @@ export function getDataColumnSidecarsFromColumnSidecar(
   );
 }
 
+/**
+ * In Gloas, data column sidecars have a simplified structure with `slot` and `beaconBlockRoot`
+ * instead of `signedBlockHeader`, `kzgCommitments`, and `kzgCommitmentsInclusionProof`.
+ */
+export function getDataColumnSidecarsForGloas(
+  slot: Slot,
+  beaconBlockRoot: Root,
+  cellsAndKzgProofs: {cells: Uint8Array[]; proofs: Uint8Array[]}[]
+): gloas.DataColumnSidecars {
+  // No need to create data column sidecars if there are no blobs
+  if (cellsAndKzgProofs.length === 0) {
+    return [];
+  }
+
+  const sidecars: gloas.DataColumnSidecars = [];
+  for (let columnIndex = 0; columnIndex < NUMBER_OF_COLUMNS; columnIndex++) {
+    const column: Uint8Array[] = [];
+    const kzgProofs: Uint8Array[] = [];
+    for (const {cells, proofs} of cellsAndKzgProofs) {
+      column.push(cells[columnIndex]);
+      kzgProofs.push(proofs[columnIndex]);
+    }
+    sidecars.push({
+      index: columnIndex,
+      column,
+      kzgProofs,
+      slot,
+      beaconBlockRoot,
+    });
+  }
+  return sidecars;
+}
+
 /**
  * If we receive more than half of NUMBER_OF_COLUMNS (64) we should recover all remaining columns
  */

package/src/util/multifork.ts

@@ -9,6 +9,11 @@ import {getSlotFromSignedBeaconBlockSerialized} from "./sszBytes.js";
  */
 const SLOT_BYTE_COUNT = 8;
 
+/**
+ * SSZ offset uint32
+ */
+const OFFSET_BYTE_COUNT = 4;
+
 /**
  * 8 + 32 = 40
  * ```
@@ -67,3 +72,43 @@ export function getLightClientHeaderTypeFromBytes(
   );
   return config.getPostAltairForkTypes(slot).LightClientHeader;
 }
+
+/**
+ * Position of first offset in DataColumnSidecar (after index field)
+ *
+ * Fulu DataColumnSidecar (6 fields):
+ *   index: uint64 [fixed - 8 bytes]
+ *   column: List [variable - 4-byte offset]
+ *   kzgCommitments: List [variable - 4-byte offset]
+ *   kzgProofs: List [variable - 4-byte offset]
+ *   signedBlockHeader: Container [fixed - 208 bytes]
+ *   kzgCommitmentsInclusionProof: Vector[Bytes32, 4] [fixed - 128 bytes]
+ *   => First offset value = 8 + 4 + 4 + 4 + 208 + 128 = 356
+ *
+ * Gloas DataColumnSidecar (5 fields):
+ *   index: uint64 [fixed - 8 bytes]
+ *   column: List [variable - 4-byte offset]
+ *   kzgProofs: List [variable - 4-byte offset]
+ *   slot: uint64 [fixed - 8 bytes]
+ *   beaconBlockRoot: Bytes32 [fixed - 32 bytes]
+ *   => First offset value = 8 + 4 + 4 + 8 + 32 = 56
+ */
+const FIRST_OFFSET_POSITION_IN_DATA_COLUMN_SIDECAR = 8;
+const GLOAS_DATA_COLUMN_SIDECAR_FIRST_OFFSET = 56;
+
+/**
+ * Determines if DataColumnSidecar bytes are from Gloas fork by checking the SSZ offset structure.
+ *
+ * The first offset (bytes 8-12) indicates where variable-size data begins:
+ * - Gloas: 56 (small fixed section)
+ * - Fulu: 356
+ */
+export function isGloasDataColumnSidecarBytes(bytes: Uint8Array): boolean {
+  const firstOffset = bytesToInt(
+    bytes.subarray(
+      FIRST_OFFSET_POSITION_IN_DATA_COLUMN_SIDECAR,
+      FIRST_OFFSET_POSITION_IN_DATA_COLUMN_SIDECAR + OFFSET_BYTE_COUNT
+    )
+  );
+  return firstOffset === GLOAS_DATA_COLUMN_SIDECAR_FIRST_OFFSET;
+}

package/src/util/serializedCache.ts

@@ -14,6 +14,11 @@ export class SerializedCache {
     this.map.set(obj, serialized);
   }
 
+  /**
+   * Replace the internal WeakMap to force GC of all cached entries.
+   * Must only be called after all DB writes that may read from this cache have completed,
+   * otherwise cached serialized bytes will be unavailable and data will be re-serialized unnecessarily.
+   */
   clear(): void {
     this.map = new WeakMap();
   }