@lodestar/beacon-node 1.41.0-dev.983b1a457b → 1.41.0-dev.9939b12b53

package/src/network/gossip/gossipsub.ts

@@ -1,10 +1,18 @@
+import {
+  type GossipSub,
+  type GossipSubEvents,
+  type PublishResult,
+  StrictNoSign,
+  type TopicValidatorResult,
+  gossipsub,
+} from "@libp2p/gossipsub";
+import type {MetricsRegister, TopicLabel, TopicStrToLabel} from "@libp2p/gossipsub/metrics";
+import type {PeerScoreParams, PeerScoreStatsDump} from "@libp2p/gossipsub/score";
+import type {AddrInfo, PublishOpts, TopicStr} from "@libp2p/gossipsub/types";
+import type {PeerId} from "@libp2p/interface";
 import {peerIdFromString} from "@libp2p/peer-id";
-import {multiaddr} from "@multiformats/multiaddr";
+import {type Multiaddr, multiaddr} from "@multiformats/multiaddr";
 import {ENR} from "@chainsafe/enr";
-import {GossipSub, GossipsubEvents} from "@chainsafe/libp2p-gossipsub";
-import {MetricsRegister, TopicLabel, TopicStrToLabel} from "@chainsafe/libp2p-gossipsub/metrics";
-import {PeerScoreParams} from "@chainsafe/libp2p-gossipsub/score";
-import {AddrInfo, SignaturePolicy, TopicStr} from "@chainsafe/libp2p-gossipsub/types";
 import {routes} from "@lodestar/api";
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
 import {ATTESTATION_SUBNET_COUNT, SLOTS_PER_EPOCH, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
@@ -69,6 +77,24 @@ export type Eth2GossipsubOpts = {
 
 export type ForkBoundaryLabel = string;
 
+// Many of the internal properties we need are not available on the public interface,
+// so we create an extended type here to avoid excessive type assertions throughout the codebase.
+// Mind that any updates to the gossipsub package may require updates to this type.
+type GossipSubInternal = GossipSub & {
+  mesh: Map<string, Set<string>>;
+  peers: Map<string, PeerId>;
+  score: {score: (peerIdStr: string) => number};
+  direct: Set<string>;
+  topics: Map<string, Set<string>>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  publish: (topic: TopicStr, data: Uint8Array, opts?: PublishOpts) => Promise<PublishResult>;
+  getMeshPeers: (topic: TopicStr) => string[];
+  dumpPeerScoreStats: () => PeerScoreStatsDump;
+  getScore: (peerIdStr: string) => number;
+  reportMessageValidationResult: (msgId: string, propagationSource: string, acceptance: TopicValidatorResult) => void;
+};
+
 /**
  * Wrapper around js-libp2p-gossipsub with the following extensions:
  * - Eth2 message id
@@ -82,13 +108,14 @@ export type ForkBoundaryLabel = string;
  *
  * See https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#the-gossip-domain-gossipsub
  */
-export class Eth2Gossipsub extends GossipSub {
+export class Eth2Gossipsub {
   readonly scoreParams: Partial<PeerScoreParams>;
   private readonly config: BeaconConfig;
   private readonly logger: Logger;
   private readonly peersData: PeersData;
   private readonly events: NetworkEventBus;
   private readonly libp2p: Libp2p;
+  private readonly gossipsub: GossipSubInternal;
 
   // Internal caches
   private readonly gossipTopicCache: GossipTopicCache;
@@ -103,9 +130,6 @@ export class Eth2Gossipsub extends GossipSub {
     let metrics: Eth2GossipsubMetrics | null = null;
     if (metricsRegister) {
       metrics = createEth2GossipsubMetrics(metricsRegister);
-      metrics.gossipMesh.peersByType.addCollect(() =>
-        this.onScrapeLodestarMetrics(metrics as Eth2GossipsubMetrics, networkConfig)
-      );
     }
 
     // Parse direct peers from multiaddr strings to AddrInfo objects
@@ -113,8 +137,8 @@ export class Eth2Gossipsub extends GossipSub {
 
     // Gossipsub parameters defined here:
     // https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/phase0/p2p-interface.md#the-gossip-domain-gossipsub
-    super(modules.libp2p.services.components, {
-      globalSignaturePolicy: SignaturePolicy.StrictNoSign,
+    const gossipsubInstance = gossipsub({
+      globalSignaturePolicy: StrictNoSign,
       allowPublishToZeroTopicPeers: allowPublishToZeroPeers,
       D: gossipsubD ?? GOSSIP_D,
       Dlo: gossipsubDLow ?? GOSSIP_D_LOW,
@@ -155,7 +179,12 @@ export class Eth2Gossipsub extends GossipSub {
       // This should be large enough to not send IDONTWANT for "small" messages
       // See https://github.com/ChainSafe/lodestar/pull/7077#issuecomment-2383679472
       idontwantMinDataSize: 16829,
-    });
+    })(modules.libp2p.services.components) as GossipSubInternal;
+
+    if (metrics) {
+      metrics.gossipMesh.peersByType.addCollect(() => this.onScrapeLodestarMetrics(metrics, networkConfig));
+    }
+    this.gossipsub = gossipsubInstance;
     this.scoreParams = scoreParams;
     this.config = config;
     this.logger = logger;
@@ -164,7 +193,7 @@ export class Eth2Gossipsub extends GossipSub {
     this.libp2p = modules.libp2p;
     this.gossipTopicCache = gossipTopicCache;
 
-    this.addEventListener("gossipsub:message", this.onGossipsubMessage.bind(this));
+    this.gossipsub.addEventListener("gossipsub:message", this.onGossipsubMessage.bind(this));
     this.events.on(NetworkEvent.gossipMessageValidationResult, this.onValidationResult.bind(this));
 
     // Having access to this data is CRUCIAL for debugging. While this is a massive log, it must not be deleted.
@@ -174,6 +203,38 @@ export class Eth2Gossipsub extends GossipSub {
     }
   }
 
+  async start(): Promise<void> {
+    await this.gossipsub.start();
+  }
+
+  async stop(): Promise<void> {
+    await this.gossipsub.stop();
+  }
+
+  get mesh(): Map<string, Set<string>> {
+    return this.gossipsub.mesh;
+  }
+
+  getTopics(): TopicStr[] {
+    return this.gossipsub.getTopics();
+  }
+
+  getMeshPeers(topic: TopicStr): string[] {
+    return this.gossipsub.getMeshPeers(topic);
+  }
+
+  publish(topic: TopicStr, data: Uint8Array, opts?: PublishOpts): Promise<PublishResult> {
+    return this.gossipsub.publish(topic, data, opts);
+  }
+
+  dumpPeerScoreStats(): PeerScoreStatsDump {
+    return this.gossipsub.dumpPeerScoreStats();
+  }
+
+  getScore(peerIdStr: string): number {
+    return this.gossipsub.getScore(peerIdStr);
+  }
+
   /**
    * Subscribe to a `GossipTopic`
    */
@@ -183,7 +244,7 @@ export class Eth2Gossipsub extends GossipSub {
     this.gossipTopicCache.setTopic(topicStr, topic);
 
     this.logger.verbose("Subscribe to gossipsub topic", {topic: topicStr});
-    this.subscribe(topicStr);
+    this.gossipsub.subscribe(topicStr);
   }
 
   /**
@@ -192,15 +253,14 @@ export class Eth2Gossipsub extends GossipSub {
   unsubscribeTopic(topic: GossipTopic): void {
     const topicStr = stringifyGossipTopic(this.config, topic);
     this.logger.verbose("Unsubscribe to gossipsub topic", {topic: topicStr});
-    this.unsubscribe(topicStr);
+    this.gossipsub.unsubscribe(topicStr);
   }
 
   private onScrapeLodestarMetrics(metrics: Eth2GossipsubMetrics, networkConfig: NetworkConfig): void {
-    const mesh = this.mesh;
-    // biome-ignore lint/complexity/useLiteralKeys: `topics` is a private attribute
-    const topics = this["topics"] as Map<string, Set<string>>;
-    const peers = this.peers;
-    const score = this.score;
+    const mesh = this.gossipsub.mesh;
+    const topics = this.gossipsub.topics;
+    const peers = this.gossipsub.peers;
+    const score = this.gossipsub.score;
     const meshPeersByClient = new Map<string, number>();
     const meshPeerIdStrs = new Set<string>();
 
@@ -305,7 +365,7 @@ export class Eth2Gossipsub extends GossipSub {
     metrics.gossipPeer.score.set(gossipScores);
   }
 
-  private onGossipsubMessage(event: GossipsubEvents["gossipsub:message"]): void {
+  private onGossipsubMessage(event: GossipSubEvents["gossipsub:message"]): void {
     const {propagationSource, msgId, msg} = event.detail;
 
     // Also validates that the topicStr is known
@@ -341,7 +401,7 @@ export class Eth2Gossipsub extends GossipSub {
     // Without this we'll have huge event loop lag
     // See https://github.com/ChainSafe/lodestar/issues/5604
     callInNextEventLoop(() => {
-      this.reportMessageValidationResult(data.msgId, data.propagationSource, data.acceptance);
+      this.gossipsub.reportMessageValidationResult(data.msgId, data.propagationSource, data.acceptance);
     });
   }
 
@@ -379,7 +439,7 @@ export class Eth2Gossipsub extends GossipSub {
     }
 
     // Add to direct peers set only after addresses are stored
-    this.direct.add(peerIdStr);
+    this.gossipsub.direct.add(peerIdStr);
 
     this.logger.info("Added direct peer via API", {peerId: peerIdStr});
     return peerIdStr;
@@ -389,7 +449,7 @@ export class Eth2Gossipsub extends GossipSub {
    * Remove a peer from direct peers.
    */
   removeDirectPeer(peerIdStr: string): boolean {
-    const removed = this.direct.delete(peerIdStr);
+    const removed = this.gossipsub.direct.delete(peerIdStr);
     if (removed) {
       this.logger.info("Removed direct peer via API", {peerId: peerIdStr});
     }
@@ -400,7 +460,7 @@ export class Eth2Gossipsub extends GossipSub {
    * Get list of current direct peer IDs.
    */
   getDirectPeers(): string[] {
-    return Array.from(this.direct);
+    return Array.from(this.gossipsub.direct);
   }
 }
 
@@ -477,19 +537,24 @@ export function parseDirectPeers(directPeerStrs: routes.lodestar.DirectPeer[], l
         const enr = ENR.decodeTxt(peerStr);
         const peerId = enr.peerId;
 
-        // Get TCP multiaddr from ENR
-        const multiaddrTCP = enr.getLocationMultiaddr("tcp");
-        if (!multiaddrTCP) {
-          logger.warn("ENR does not contain TCP multiaddr", {enr: peerStr});
+        // Get all available transport multiaddrs from ENR
+        const addrs = [enr.getLocationMultiaddr("quic"), enr.getLocationMultiaddr("tcp")].filter(
+          (a): a is Multiaddr => a != null
+        );
+        if (addrs.length === 0) {
+          logger.warn("ENR does not contain any transport multiaddr", {enr: peerStr});
           continue;
         }
 
         directPeers.push({
           id: peerId,
-          addrs: [multiaddrTCP],
+          addrs,
         });
 
-        logger.info("Added direct peer from ENR", {peerId: peerId.toString(), addr: multiaddrTCP.toString()});
+        logger.info("Added direct peer from ENR", {
+          peerId: peerId.toString(),
+          addrs: addrs.map((a) => a.toString()).join(", "),
+        });
       } catch (e) {
         logger.warn("Failed to parse direct peer ENR", {enr: peerStr}, e as Error);
       }
@@ -498,7 +563,8 @@ export function parseDirectPeers(directPeerStrs: routes.lodestar.DirectPeer[], l
       try {
         const ma = multiaddr(peerStr);
 
-        const peerIdStr = ma.getPeerId();
+        const peerIdComponent = ma.getComponents().findLast((component) => component.name === "p2p");
+        const peerIdStr = peerIdComponent?.value;
         if (!peerIdStr) {
           logger.warn("Direct peer multiaddr must contain /p2p/ component with peer ID", {multiaddr: peerStr});
           continue;

package/src/network/gossip/interface.ts

@@ -1,9 +1,10 @@
-import {Message, TopicValidatorResult} from "@libp2p/interface";
-import {Libp2p} from "libp2p";
-import {PeerIdStr} from "@chainsafe/libp2p-gossipsub/types";
+import type {Message, TopicValidatorResult} from "@libp2p/gossipsub";
+import type {PeerIdStr} from "@libp2p/gossipsub/types";
+import type {Libp2p} from "libp2p";
 import {BeaconConfig, ForkBoundary} from "@lodestar/config";
 import {
   AttesterSlashing,
+  DataColumnSidecar,
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
   SignedAggregateAndProof,
@@ -14,7 +15,6 @@ import {
   altair,
   capella,
   deneb,
-  fulu,
   gloas,
   phase0,
 } from "@lodestar/types";
@@ -98,7 +98,7 @@ export type GossipTypeMap = {
   [GossipType.blob_sidecar]: deneb.BlobSidecar;
   [GossipType.beacon_aggregate_and_proof]: SignedAggregateAndProof;
   [GossipType.beacon_attestation]: SingleAttestation;
-  [GossipType.data_column_sidecar]: fulu.DataColumnSidecar;
+  [GossipType.data_column_sidecar]: DataColumnSidecar;
   [GossipType.voluntary_exit]: phase0.SignedVoluntaryExit;
   [GossipType.proposer_slashing]: phase0.ProposerSlashing;
   [GossipType.attester_slashing]: AttesterSlashing;
@@ -117,7 +117,7 @@ export type GossipFnByType = {
   [GossipType.blob_sidecar]: (blobSidecar: deneb.BlobSidecar) => Promise<void> | void;
   [GossipType.beacon_aggregate_and_proof]: (aggregateAndProof: SignedAggregateAndProof) => Promise<void> | void;
   [GossipType.beacon_attestation]: (attestation: SingleAttestation) => Promise<void> | void;
-  [GossipType.data_column_sidecar]: (dataColumnSidecar: fulu.DataColumnSidecar) => Promise<void> | void;
+  [GossipType.data_column_sidecar]: (dataColumnSidecar: DataColumnSidecar) => Promise<void> | void;
   [GossipType.voluntary_exit]: (voluntaryExit: phase0.SignedVoluntaryExit) => Promise<void> | void;
   [GossipType.proposer_slashing]: (proposerSlashing: phase0.ProposerSlashing) => Promise<void> | void;
   [GossipType.attester_slashing]: (attesterSlashing: AttesterSlashing) => Promise<void> | void;

package/src/network/gossip/scoringParameters.ts

@@ -1,9 +1,9 @@
 import {
-  PeerScoreParams,
-  PeerScoreThresholds,
-  TopicScoreParams,
+  type PeerScoreParams,
+  type PeerScoreThresholds,
+  type TopicScoreParams,
   defaultTopicScoreParams,
-} from "@chainsafe/libp2p-gossipsub/score";
+} from "@libp2p/gossipsub/score";
 import {BeaconConfig} from "@lodestar/config";
 import {ATTESTATION_SUBNET_COUNT, PTC_SIZE, SLOTS_PER_EPOCH, TARGET_AGGREGATORS_PER_COMMITTEE} from "@lodestar/params";
 import {computeCommitteeCount} from "@lodestar/state-transition";

package/src/network/gossip/topic.ts

@@ -6,6 +6,7 @@ import {
   SYNC_COMMITTEE_SUBNET_COUNT,
   isForkPostAltair,
   isForkPostElectra,
+  isForkPostFulu,
 } from "@lodestar/params";
 import {Attestation, SingleAttestation, ssz, sszTypesFor} from "@lodestar/types";
 import {GossipAction, GossipActionError, GossipErrorCode} from "../../chain/errors/gossipValidation.js";
@@ -92,7 +93,7 @@ export function getGossipSSZType(topic: GossipTopic) {
     case GossipType.blob_sidecar:
       return ssz.deneb.BlobSidecar;
     case GossipType.data_column_sidecar:
-      return ssz.fulu.DataColumnSidecar;
+      return isForkPostFulu(fork) ? sszTypesFor(fork).DataColumnSidecar : ssz.fulu.DataColumnSidecar;
     case GossipType.beacon_aggregate_and_proof:
       return sszTypesFor(fork).SignedAggregateAndProof;
     case GossipType.beacon_attestation:

package/src/network/interface.ts

@@ -1,5 +1,5 @@
-import {Identify} from "@libp2p/identify";
-import {
+import type {Identify} from "@libp2p/identify";
+import type {
   ComponentLogger,
   ConnectionGater,
   ConnectionProtector,
@@ -16,9 +16,10 @@ import {
 } from "@libp2p/interface";
 import type {AddressManager, ConnectionManager, Registrar, TransportManager} from "@libp2p/interface-internal";
 import type {Datastore} from "interface-datastore";
-import {Libp2p as ILibp2p} from "libp2p";
+import type {Libp2p as ILibp2p} from "libp2p";
 import {
   AttesterSlashing,
+  DataColumnSidecar,
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
   SignedAggregateAndProof,
@@ -31,6 +32,7 @@ import {
   capella,
   deneb,
   fulu,
+  gloas,
   phase0,
 } from "@lodestar/types";
 import {BlockInputSource} from "../chain/blocks/blockInput/types.js";
@@ -86,7 +88,7 @@ export interface INetwork extends INetworkCorePublic {
   publishBlobSidecar(blobSidecar: deneb.BlobSidecar): Promise<number>;
   publishBeaconAggregateAndProof(aggregateAndProof: SignedAggregateAndProof): Promise<number>;
   publishBeaconAttestation(attestation: SingleAttestation, subnet: SubnetID): Promise<number>;
-  publishDataColumnSidecar(dataColumnSideCar: fulu.DataColumnSidecar): Promise<number>;
+  publishDataColumnSidecar(dataColumnSideCar: DataColumnSidecar): Promise<number>;
   publishVoluntaryExit(voluntaryExit: phase0.SignedVoluntaryExit): Promise<number>;
   publishBlsToExecutionChange(blsToExecutionChange: capella.SignedBLSToExecutionChange): Promise<number>;
   publishProposerSlashing(proposerSlashing: phase0.ProposerSlashing): Promise<number>;
@@ -95,6 +97,7 @@ export interface INetwork extends INetworkCorePublic {
   publishContributionAndProof(contributionAndProof: altair.SignedContributionAndProof): Promise<number>;
   publishLightClientFinalityUpdate(update: LightClientFinalityUpdate): Promise<number>;
   publishLightClientOptimisticUpdate(update: LightClientOptimisticUpdate): Promise<number>;
+  publishSignedExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope): Promise<number>;
 
   // Debug
   dumpGossipQueue(gossipType: GossipType): Promise<PendingGossipsubMessage[]>;

package/src/network/libp2p/index.ts

@@ -1,15 +1,16 @@
 import {bootstrap} from "@libp2p/bootstrap";
 import {identify} from "@libp2p/identify";
-import {PrivateKey} from "@libp2p/interface";
+import type {PrivateKey} from "@libp2p/interface";
 import {mdns} from "@libp2p/mdns";
 import {mplex} from "@libp2p/mplex";
 import {prometheusMetrics} from "@libp2p/prometheus-metrics";
 import {tcp} from "@libp2p/tcp";
-import {createLibp2p} from "libp2p";
+import {Libp2pInit, createLibp2p} from "libp2p";
 import {Registry} from "prom-client";
 import {ENR} from "@chainsafe/enr";
 import {noise} from "@chainsafe/libp2p-noise";
 import {asCrypto, defaultCrypto} from "@chainsafe/libp2p-noise/crypto";
+import {quic} from "@chainsafe/libp2p-quic";
 import {Libp2p, LodestarComponents} from "../interface.js";
 import {NetworkOptions, defaultNetworkOptions} from "../options.js";
 import {Eth2PeerDataStore} from "../peers/datastore.js";
@@ -21,11 +22,14 @@ export type NodeJsLibp2pOpts = {
   metricsRegistry?: Registry;
 };
 
-export async function getDiscv5Multiaddrs(bootEnrs: string[]): Promise<string[]> {
+export async function getDiscv5Multiaddrs(bootEnrs: string[], quicEnabled?: boolean): Promise<string[]> {
   const bootMultiaddrs = [];
   for (const enrStr of bootEnrs) {
     const enr = ENR.decodeTxt(enrStr);
-    const multiaddrWithPeerId = (await enr.getFullMultiaddr("tcp"))?.toString();
+    // Prefer QUIC over TCP when available
+    const quicMultiaddr = quicEnabled ? (await enr.getFullMultiaddr("quic"))?.toString() : undefined;
+    const tcpMultiaddr = (await enr.getFullMultiaddr("tcp"))?.toString();
+    const multiaddrWithPeerId = quicMultiaddr ?? tcpMultiaddr;
     if (multiaddrWithPeerId) {
       bootMultiaddrs.push(multiaddrWithPeerId);
     }
@@ -39,6 +43,7 @@ export async function createNodeJsLibp2p(
   nodeJsLibp2pOpts: NodeJsLibp2pOpts = {}
 ): Promise<Libp2p> {
   const localMultiaddrs = networkOpts.localMultiaddrs || defaultNetworkOptions.localMultiaddrs;
+  const disconnectThreshold = networkOpts.disconnectThreshold ?? defaultNetworkOptions.disconnectThreshold;
   const {peerStoreDir, disablePeerDiscovery} = nodeJsLibp2pOpts;
 
   let datastore: undefined | Eth2PeerDataStore = undefined;
@@ -52,7 +57,9 @@ export async function createNodeJsLibp2p(
     const bootMultiaddrs = [
       ...(networkOpts.bootMultiaddrs ?? defaultNetworkOptions.bootMultiaddrs ?? []),
       // Append discv5.bootEnrs to bootMultiaddrs if requested
-      ...(networkOpts.connectToDiscv5Bootnodes ? await getDiscv5Multiaddrs(networkOpts.discv5?.bootEnrs ?? []) : []),
+      ...(networkOpts.connectToDiscv5Bootnodes
+        ? await getDiscv5Multiaddrs(networkOpts.discv5?.bootEnrs ?? [], networkOpts.quic)
+        : []),
     ];
 
     if ((bootMultiaddrs.length ?? 0) > 0) {
@@ -63,6 +70,35 @@ export async function createNodeJsLibp2p(
       peerDiscovery.push(mdns());
     }
   }
+  const transports: Libp2pInit["transports"] = [];
+  if (networkOpts.tcp ?? true) {
+    transports.unshift(
+      tcp({
+        // Reject connections when the server's connection count gets high
+        maxConnections: networkOpts.maxPeers,
+        // socket option: the maximum length of the queue of pending connections
+        // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
+        // it's not safe if we increase this number
+        backlog: 5,
+        closeServerOnMaxConnections: {
+          closeAbove: networkOpts.maxPeers ?? Infinity,
+          listenBelow: networkOpts.maxPeers ?? Infinity,
+        },
+      })
+    );
+  }
+  if (networkOpts.quic) {
+    transports.unshift(
+      quic({
+        handshakeTimeout: 5_000,
+        maxIdleTimeout: 10_000,
+        keepAliveInterval: 5_000,
+        maxConcurrentStreamLimit: 256,
+        maxStreamData: 10_000_000,
+        maxConnectionData: 15_000_000,
+      })
+    );
+  }
 
   const noiseCrypto = {
     ...defaultCrypto,
@@ -74,26 +110,18 @@ export async function createNodeJsLibp2p(
 
   return createLibp2p({
     privateKey,
+    nodeInfo: {
+      name: "lodestar",
+      version: networkOpts.version ?? "unknown",
+      userAgent: networkOpts.private ? "" : networkOpts.version ? `lodestar/${networkOpts.version}` : "lodestar",
+    },
     addresses: {
       listen: localMultiaddrs,
       announce: [],
     },
     connectionEncrypters: [noise({crypto: noiseCrypto})],
-    // Reject connections when the server's connection count gets high
-    transports: [
-      tcp({
-        maxConnections: networkOpts.maxPeers,
-        // socket option: the maximum length of the queue of pending connections
-        // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
-        // it's not safe if we increase this number
-        backlog: 5,
-        closeServerOnMaxConnections: {
-          closeAbove: networkOpts.maxPeers ?? Infinity,
-          listenBelow: networkOpts.maxPeers ?? Infinity,
-        },
-      }),
-    ],
-    streamMuxers: [mplex({maxInboundStreams: 256, disconnectThreshold: networkOpts.disconnectThreshold})],
+    transports,
+    streamMuxers: [mplex({disconnectThreshold})],
     peerDiscovery,
     metrics: nodeJsLibp2pOpts.metrics
       ? prometheusMetrics({
@@ -124,7 +152,6 @@ export async function createNodeJsLibp2p(
     datastore,
     services: {
       identify: identify({
-        agentVersion: networkOpts.private ? "" : networkOpts.version ? `lodestar/${networkOpts.version}` : "lodestar",
         runOnConnectionOpen: false,
       }),
       // individual components are specified because the components object is a Proxy

package/src/network/metadata.ts

@@ -11,6 +11,7 @@ import {NetworkConfig} from "./networkConfig.js";
 
 export enum ENRKey {
   tcp = "tcp",
+  quic = "quic",
   eth2 = "eth2",
   attnets = "attnets",
   syncnets = "syncnets",

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],
@@ -521,7 +539,8 @@ export class Network implements INetwork {
         this.config.getForkSeq(this.clock.currentSlot) >= ForkSeq.altair ? [Version.V2] : [Version.V2, Version.V1],
         request
       ),
-      request
+      request,
+      this.chain.serializedCache
     );
   }
 
@@ -765,7 +784,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

@@ -29,7 +29,6 @@ export interface NetworkOptions
   useWorker?: boolean;
   maxYoungGenerationSizeMb?: number;
   disableLightClientServer?: boolean;
-
   /**
    * During E2E tests observe a lot of following `missing stream`:
    *
@@ -48,11 +47,14 @@ export interface NetworkOptions
    * We need to increase this only for the testing purpose
    */
   disconnectThreshold?: number;
+  quic?: boolean;
+  tcp?: boolean;
 }
 
 export const defaultNetworkOptions: NetworkOptions = {
   maxPeers: 210, // Allow some room above targetPeers for new inbound peers
   targetPeers: 200,
+  // In CLI usage this is typically overridden; when unset it serves as a fallback default (e.g. programmatic usage/tests)
   localMultiaddrs: ["/ip4/0.0.0.0/tcp/9000", "/ip6/::/tcp/9000"],
   bootMultiaddrs: [],
   /** disabled by default */
@@ -67,9 +69,14 @@ export const defaultNetworkOptions: NetworkOptions = {
   slotsToSubscribeBeforeAggregatorDuty: 2,
   // This will enable the light client server by default
   disableLightClientServer: false,
+  quic: false,
+  tcp: true,
   // specific option for fulu
   //   - this is the same to TARGET_SUBNET_PEERS
   //   - 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,
 };