@lodestar/beacon-node 1.42.0-dev.84f3b9f030 → 1.42.0-dev.89ddaaeed2

package/src/chain/validation/dataColumnSidecar.ts

@@ -10,11 +10,13 @@ import {
   getBlockHeaderProposerSignatureSetByHeaderSlot,
   getBlockHeaderProposerSignatureSetByParentStateSlot,
 } from "@lodestar/state-transition";
-import {DataColumnSidecar, Root, Slot, SubnetID, fulu, ssz} from "@lodestar/types";
+import {DataColumnSidecar, Root, Slot, SubnetID, fulu, gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toRootHex, verifyMerkleBranch} from "@lodestar/utils";
 import {BeaconMetrics} from "../../metrics/metrics/beacon.js";
 import {Metrics} from "../../metrics/metrics.js";
+import {getDataColumnSidecarSlot} from "../../util/dataColumns.js";
 import {kzg} from "../../util/kzg.js";
+import {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 import {
   DataColumnSidecarErrorCode,
   DataColumnSidecarGossipError,
@@ -26,7 +28,7 @@ import {RegenCaller} from "../regen/interface.js";
 
 // SPEC FUNCTION
 // https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/p2p-interface.md#data_column_sidecar_subnet_id
-export async function validateGossipDataColumnSidecar(
+export async function validateGossipFuluDataColumnSidecar(
   chain: IBeaconChain,
   dataColumnSidecar: fulu.DataColumnSidecar,
   gossipSubnet: SubnetID,
@@ -36,7 +38,7 @@ export async function validateGossipDataColumnSidecar(
   const blockRootHex = toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(blockHeader));
 
   // 1) [REJECT] The sidecar is valid as verified by verify_data_column_sidecar
-  verifyDataColumnSidecar(chain.config, dataColumnSidecar);
+  verifyFuluDataColumnSidecar(chain.config, dataColumnSidecar);
 
   // 2) [REJECT] The sidecar is for the correct subnet -- i.e. compute_subnet_for_data_column_sidecar(sidecar.index) == subnet_id
   if (computeSubnetForDataColumnSidecar(chain.config, dataColumnSidecar) !== gossipSubnet) {
@@ -203,11 +205,75 @@ export async function validateGossipDataColumnSidecar(
   //              -- Handled in seenGossipBlockInput
 }
 
+// SPEC FUNCTION
+// https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.3/specs/gloas/p2p-interface.md#data_column_sidecar_subnet_id
+export async function validateGossipGloasDataColumnSidecar(
+  chain: IBeaconChain,
+  payloadInput: PayloadEnvelopeInput,
+  dataColumnSidecar: gloas.DataColumnSidecar,
+  gossipSubnet: SubnetID,
+  metrics: Metrics | null
+): Promise<void> {
+  const blockRootHex = toRootHex(dataColumnSidecar.beaconBlockRoot);
+  const block = chain.forkChoice.getBlockHexDefaultStatus(blockRootHex);
+
+  // [IGNORE] A valid block for the sidecar's `slot` has been seen.
+  if (block === null) {
+    throw new DataColumnSidecarGossipError(GossipAction.IGNORE, {
+      code: DataColumnSidecarErrorCode.BLOCK_UNKNOWN,
+      blockRoot: blockRootHex,
+      slot: dataColumnSidecar.slot,
+    });
+  }
+
+  // [REJECT] The sidecar slot matches the slot of the block with root beacon_block_root.
+  if (block.slot !== dataColumnSidecar.slot) {
+    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+      code: DataColumnSidecarErrorCode.INCORRECT_SIDECAR_SLOT,
+      columnIndex: dataColumnSidecar.index,
+      expected: block.slot,
+      actual: dataColumnSidecar.slot,
+    });
+  }
+
+  // [REJECT] The sidecar must pass verify_data_column_sidecar against the block commitments
+  const kzgCommitments = payloadInput.getBlobKzgCommitments();
+  verifyGloasDataColumnSidecar(dataColumnSidecar, kzgCommitments);
+
+  // [REJECT] The sidecar must be on the correct subnet
+  if (computeSubnetForDataColumnSidecar(chain.config, dataColumnSidecar) !== gossipSubnet) {
+    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+      code: DataColumnSidecarErrorCode.INVALID_SUBNET,
+      columnIndex: dataColumnSidecar.index,
+      gossipSubnet,
+    });
+  }
+
+  // [REJECT] The sidecar kzg proofs must verify
+  const kzgProofTimer = metrics?.peerDas.dataColumnSidecarKzgProofsVerificationTime.startTimer();
+  try {
+    await verifyDataColumnSidecarKzgProofs(
+      kzgCommitments,
+      Array.from({length: dataColumnSidecar.column.length}, () => dataColumnSidecar.index),
+      dataColumnSidecar.column,
+      dataColumnSidecar.kzgProofs
+    );
+  } catch {
+    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+      code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF,
+      slot: dataColumnSidecar.slot,
+      columnIndex: dataColumnSidecar.index,
+    });
+  } finally {
+    kzgProofTimer?.();
+  }
+}
+
 /**
  * SPEC FUNCTION
  * https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/p2p-interface.md#verify_data_column_sidecar
  */
-function verifyDataColumnSidecar(config: ChainForkConfig, dataColumnSidecar: fulu.DataColumnSidecar): void {
+function verifyFuluDataColumnSidecar(config: ChainForkConfig, dataColumnSidecar: fulu.DataColumnSidecar): void {
   if (dataColumnSidecar.index >= NUMBER_OF_COLUMNS) {
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
       code: DataColumnSidecarErrorCode.INVALID_INDEX,
@@ -250,6 +316,41 @@ function verifyDataColumnSidecar(config: ChainForkConfig, dataColumnSidecar: ful
   }
 }
 
+/**
+ * SPEC FUNCTION
+ * https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.3/specs/gloas/p2p-interface.md#modified-verify_data_column_sidecar
+ */
+function verifyGloasDataColumnSidecar(dataColumnSidecar: gloas.DataColumnSidecar, kzgCommitments: Uint8Array[]): void {
+  const slot = getDataColumnSidecarSlot(dataColumnSidecar);
+  if (dataColumnSidecar.index >= NUMBER_OF_COLUMNS) {
+    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+      code: DataColumnSidecarErrorCode.INVALID_INDEX,
+      slot,
+      columnIndex: dataColumnSidecar.index,
+    });
+  }
+
+  if (dataColumnSidecar.column.length === 0) {
+    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+      code: DataColumnSidecarErrorCode.NO_COMMITMENTS,
+      slot,
+      columnIndex: dataColumnSidecar.index,
+    });
+  }
+
+  if (
+    dataColumnSidecar.column.length !== kzgCommitments.length ||
+    dataColumnSidecar.column.length !== dataColumnSidecar.kzgProofs.length
+  ) {
+    throw new DataColumnSidecarGossipError(GossipAction.REJECT, {
+      code: DataColumnSidecarErrorCode.MISMATCHED_LENGTHS,
+      columnLength: dataColumnSidecar.column.length,
+      commitmentsLength: kzgCommitments.length,
+      proofsLength: dataColumnSidecar.kzgProofs.length,
+    });
+  }
+}
+
 /**
  * SPEC FUNCTION
  * https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.4/specs/fulu/p2p-interface.md#verify_data_column_sidecar_kzg_proofs
@@ -287,19 +388,19 @@ export function verifyDataColumnSidecarInclusionProof(dataColumnSidecar: fulu.Da
 }
 
 /**
- * Validate a subset of data column sidecars in a block
+ * Validate a subset of fulu data column sidecars against a block
  *
  * Requires the block to be known to the node
  *
  * NOTE: chain is optional to skip signature verification. Helpful for testing purposes and so that can control whether
  * signature gets checked depending on the reqresp method that is being checked
  */
-export async function validateBlockDataColumnSidecars(
+export async function validateFuluBlockDataColumnSidecars(
   chain: IBeaconChain | null,
   blockSlot: Slot,
   blockRoot: Root,
   blockBlobCount: number,
-  dataColumnSidecars: fulu.DataColumnSidecars,
+  dataColumnSidecars: fulu.DataColumnSidecar[],
   metrics?: BeaconMetrics["peerDas"] | null
 ): Promise<void> {
   metrics?.dataColumnSidecarProcessingRequests.inc(dataColumnSidecars.length);
@@ -467,6 +568,128 @@ export async function validateBlockDataColumnSidecars(
         "DataColumnSidecar has invalid KZG proof batch"
       );
     }
+
+    metrics?.dataColumnSidecarProcessingSuccesses.inc();
+  } finally {
+    verificationTimer?.();
+  }
+}
+
+/**
+ * Validate a subset of gloas data column sidecars against a block
+ * Gloas sidecars don't carry signed block headers, kzg commitments, or inclusion proofs
+ */
+export async function validateGloasBlockDataColumnSidecars(
+  blockSlot: Slot,
+  blockRoot: Root,
+  blockKzgCommitments: Uint8Array[],
+  dataColumnSidecars: gloas.DataColumnSidecar[],
+  metrics?: BeaconMetrics["peerDas"] | null
+): Promise<void> {
+  metrics?.dataColumnSidecarProcessingRequests.inc(dataColumnSidecars.length);
+  const verificationTimer = metrics?.dataColumnSidecarGossipVerificationTime.startTimer();
+  try {
+    if (dataColumnSidecars.length === 0) {
+      return;
+    }
+
+    if (blockKzgCommitments.length === 0) {
+      throw new DataColumnSidecarValidationError(
+        {
+          code: DataColumnSidecarErrorCode.INCORRECT_SIDECAR_COUNT,
+          slot: blockSlot,
+          expected: 0,
+          actual: dataColumnSidecars.length,
+        },
+        "Block has no blob commitments but data column sidecars were provided"
+      );
+    }
+
+    const commitments: Uint8Array[] = [];
+    const cellIndices: number[] = [];
+    const cells: Uint8Array[] = [];
+    const proofs: Uint8Array[] = [];
+    for (const columnSidecar of dataColumnSidecars) {
+      if (columnSidecar.slot !== blockSlot) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.INCORRECT_SIDECAR_SLOT,
+          columnIndex: columnSidecar.index,
+          expected: blockSlot,
+          actual: columnSidecar.slot,
+        });
+      }
+
+      if (!byteArrayEquals(columnSidecar.beaconBlockRoot, blockRoot)) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.INCORRECT_BLOCK,
+          slot: blockSlot,
+          columnIndex: columnSidecar.index,
+          expected: toRootHex(blockRoot),
+          actual: toRootHex(columnSidecar.beaconBlockRoot),
+        });
+      }
+
+      if (columnSidecar.index >= NUMBER_OF_COLUMNS) {
+        throw new DataColumnSidecarValidationError(
+          {
+            code: DataColumnSidecarErrorCode.INVALID_INDEX,
+            slot: blockSlot,
+            columnIndex: columnSidecar.index,
+          },
+          "DataColumnSidecar has invalid index"
+        );
+      }
+
+      if (columnSidecar.column.length !== blockKzgCommitments.length) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.INCORRECT_CELL_COUNT,
+          slot: blockSlot,
+          columnIndex: columnSidecar.index,
+          expected: blockKzgCommitments.length,
+          actual: columnSidecar.column.length,
+        });
+      }
+
+      if (columnSidecar.column.length !== columnSidecar.kzgProofs.length) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.INCORRECT_KZG_PROOF_COUNT,
+          slot: blockSlot,
+          columnIndex: columnSidecar.index,
+          expected: columnSidecar.column.length,
+          actual: columnSidecar.kzgProofs.length,
+        });
+      }
+
+      commitments.push(...blockKzgCommitments);
+      cellIndices.push(...Array.from({length: columnSidecar.column.length}, () => columnSidecar.index));
+      cells.push(...columnSidecar.column);
+      proofs.push(...columnSidecar.kzgProofs);
+    }
+
+    let reason: string | undefined;
+    // batch verification for the cases: downloadByRange and downloadByRoot
+    const kzgVerificationTimer = metrics?.kzgVerificationDataColumnBatchTime.startTimer();
+    try {
+      const valid = await kzg.asyncVerifyCellKzgProofBatch(commitments, cellIndices, cells, proofs);
+      if (!valid) {
+        reason = "Invalid KZG proof batch";
+      }
+    } catch (e) {
+      reason = (e as Error).message;
+    } finally {
+      kzgVerificationTimer?.();
+    }
+    if (reason !== undefined) {
+      throw new DataColumnSidecarValidationError(
+        {
+          code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF_BATCH,
+          slot: blockSlot,
+          reason,
+        },
+        "DataColumnSidecar has invalid KZG proof batch"
+      );
+    }
+
     metrics?.dataColumnSidecarProcessingSuccesses.inc();
   } finally {
     verificationTimer?.();

package/src/db/buckets.ts

@@ -67,8 +67,8 @@ export enum Bucket {
   // lightClient_bestLightClientUpdate = 55, // SyncPeriod -> LightClientUpdate // DEPRECATED on v1.5.0
   lightClient_bestLightClientUpdate = 56, // SyncPeriod -> [Slot, LightClientUpdate]
 
-  fulu_dataColumnSidecars = 57, // FULU BeaconBlockRoot -> DataColumnSidecars
-  fulu_dataColumnSidecarsArchive = 58, // FULU BeaconBlockSlot -> DataColumnSidecars
+  allForks_dataColumnSidecars = 57, // BeaconBlockRoot -> DataColumnSidecars
+  allForks_dataColumnSidecarsArchive = 58, // BeaconBlockSlot -> DataColumnSidecars
 
   gloas_executionPayloadEnvelope = 59, // GLOAS BeaconBlockRoot -> SignedExecutionPayloadEnvelope
   gloas_executionPayloadEnvelopeArchive = 60, // GLOAS Slot -> SignedExecutionPayloadEnvelope

package/src/db/repositories/dataColumnSidecar.ts

@@ -18,8 +18,10 @@ type BlockRoot = Root;
  */
 export class DataColumnSidecarRepository extends PrefixedRepository<BlockRoot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
-    const bucket = Bucket.fulu_dataColumnSidecars;
-    super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
+    const bucket = Bucket.allForks_dataColumnSidecars;
+    // Type won't be used since we select it dynamically based on fork
+    const type = ssz.fulu.DataColumnSidecar;
+    super(config, db, bucket, type, getBucketNameByValue(bucket));
   }
 
   /**

package/src/db/repositories/dataColumnSidecarArchive.ts

@@ -16,8 +16,10 @@ const SLOT_BYTE_SIZE = 8;
  */
 export class DataColumnSidecarArchiveRepository extends PrefixedRepository<Slot, ColumnIndex, DataColumnSidecar> {
   constructor(config: ChainForkConfig, db: Db) {
-    const bucket = Bucket.fulu_dataColumnSidecarsArchive;
-    super(config, db, bucket, ssz.fulu.DataColumnSidecar, getBucketNameByValue(bucket));
+    const bucket = Bucket.allForks_dataColumnSidecarsArchive;
+    // Type won't be used since we select it dynamically based on fork
+    const type = ssz.fulu.DataColumnSidecar;
+    super(config, db, bucket, type, getBucketNameByValue(bucket));
   }
 
   /**

package/src/metrics/metrics/lodestar.ts

@@ -1746,6 +1746,40 @@ export function createLodestarMetrics(
       }),
     },
 
+    // some gossip messages need to wait for payload to be processed before they can be processed
+    awaitingPayloadGossipMessages: {
+      queue: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_total",
+        help: "Total number of gossip messages waiting for payload to be processed",
+        labelNames: ["topic"],
+      }),
+      countPerSlot: register.gauge({
+        name: "lodestar_awaiting_payload_gossip_messages_per_slot_total",
+        help: "Total number of gossip messages waiting for payload to be processed per slot",
+      }),
+      resolve: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_resolve_total",
+        help: "Total number of gossip messages are reprocessed",
+        labelNames: ["topic"],
+      }),
+      waitSecBeforeResolve: register.gauge<{topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_wait_time_resolve_seconds",
+        help: "Time to wait for unknown payload in seconds",
+        labelNames: ["topic"],
+      }),
+      // having 2 labels here is not great for performance, however it's rarely happening and having the reason label is important for debugging
+      reject: register.gauge<{reason: ReprocessRejectReason; topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_reject_total",
+        help: "Total number of gossip messages are rejected to reprocess",
+        labelNames: ["reason", "topic"],
+      }),
+      waitSecBeforeReject: register.gauge<{reason: ReprocessRejectReason; topic: GossipType}>({
+        name: "lodestar_awaiting_payload_gossip_messages_wait_time_reject_seconds",
+        help: "Time to wait for unknown payload before being rejected",
+        labelNames: ["reason", "topic"],
+      }),
+    },
+
     lightclientServer: {
       onSyncAggregate: register.gauge<{event: string}>({
         name: "lodestar_lightclient_server_on_sync_aggregate_event_total",

package/src/network/interface.ts

@@ -74,6 +74,7 @@ export interface INetwork extends INetworkCorePublic {
   shouldAggregate(subnet: SubnetID, slot: Slot): boolean;
   reStatusPeers(peers: PeerIdStr[]): Promise<void>;
   searchUnknownBlock(slotRoot: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void;
+  searchUnknownEnvelope(slotRoot: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void;
   // ReqResp
   sendBeaconBlocksByRange(peerId: PeerIdStr, request: phase0.BeaconBlocksByRangeRequest): Promise<SignedBeaconBlock[]>;
   sendBeaconBlocksByRoot(peerId: PeerIdStr, request: BeaconBlocksByRootRequest): Promise<SignedBeaconBlock[]>;
@@ -82,11 +83,11 @@ export interface INetwork extends INetworkCorePublic {
   sendDataColumnSidecarsByRange(
     peerId: PeerIdStr,
     request: fulu.DataColumnSidecarsByRangeRequest
-  ): Promise<fulu.DataColumnSidecar[]>;
+  ): Promise<DataColumnSidecar[]>;
   sendDataColumnSidecarsByRoot(
     peerId: PeerIdStr,
     request: DataColumnSidecarsByRootRequest
-  ): Promise<fulu.DataColumnSidecar[]>;
+  ): Promise<DataColumnSidecar[]>;
   sendExecutionPayloadEnvelopesByRange(
     peerId: PeerIdStr,
     request: gloas.ExecutionPayloadEnvelopesByRangeRequest

package/src/network/libp2p/index.ts

@@ -44,6 +44,8 @@ export async function createNodeJsLibp2p(
 ): Promise<Libp2p> {
   const localMultiaddrs = networkOpts.localMultiaddrs || defaultNetworkOptions.localMultiaddrs;
   const disconnectThreshold = networkOpts.disconnectThreshold ?? defaultNetworkOptions.disconnectThreshold;
+  const tcpEnabled = networkOpts.tcp ?? defaultNetworkOptions.tcp;
+  const quicEnabled = networkOpts.quic ?? defaultNetworkOptions.quic;
   const {peerStoreDir, disablePeerDiscovery} = nodeJsLibp2pOpts;
 
   let datastore: undefined | Eth2PeerDataStore = undefined;
@@ -58,7 +60,7 @@ export async function createNodeJsLibp2p(
       ...(networkOpts.bootMultiaddrs ?? defaultNetworkOptions.bootMultiaddrs ?? []),
       // Append discv5.bootEnrs to bootMultiaddrs if requested
       ...(networkOpts.connectToDiscv5Bootnodes
-        ? await getDiscv5Multiaddrs(networkOpts.discv5?.bootEnrs ?? [], networkOpts.quic)
+        ? await getDiscv5Multiaddrs(networkOpts.discv5?.bootEnrs ?? [], quicEnabled)
         : []),
     ];
 
@@ -71,7 +73,7 @@ export async function createNodeJsLibp2p(
     }
   }
   const transports: Libp2pInit["transports"] = [];
-  if (networkOpts.tcp ?? true) {
+  if (tcpEnabled) {
     transports.unshift(
       tcp({
         // Reject connections when the server's connection count gets high
@@ -87,22 +89,26 @@ export async function createNodeJsLibp2p(
       })
     );
   }
-  if (networkOpts.quic) {
+  if (quicEnabled) {
     const quicMultiaddrs = localMultiaddrs.filter((ma) => ma.includes("/quic-v1"));
     const hasIpv4Quic = quicMultiaddrs.some((ma) => ma.includes("/ip4/"));
     const hasIpv6Quic = quicMultiaddrs.some((ma) => ma.includes("/ip6/"));
-    transports.unshift(
-      quic({
-        handshakeTimeout: 5_000,
-        maxIdleTimeout: 10_000,
-        keepAliveInterval: 5_000,
-        maxConcurrentStreamLimit: 256,
-        maxStreamData: 10_000_000,
-        maxConnectionData: 15_000_000,
-        ipv4: hasIpv4Quic,
-        ipv6: hasIpv6Quic,
-      })
-    );
+    // Only add QUIC transport if at least one QUIC listen address is configured,
+    // otherwise the transport constructor will throw
+    if (hasIpv4Quic || hasIpv6Quic) {
+      transports.unshift(
+        quic({
+          handshakeTimeout: 5_000,
+          maxIdleTimeout: 10_000,
+          keepAliveInterval: 5_000,
+          maxConcurrentStreamLimit: 256,
+          maxStreamData: 10_000_000,
+          maxConnectionData: 15_000_000,
+          ipv4: hasIpv4Quic,
+          ipv6: hasIpv6Quic,
+        })
+      );
+    }
   }
 
   const noiseCrypto = {

package/src/network/network.ts

@@ -11,7 +11,6 @@ import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {
   AttesterSlashing,
   DataColumnSidecar,
-  DataColumnSidecars,
   LightClientBootstrap,
   LightClientFinalityUpdate,
   LightClientOptimisticUpdate,
@@ -286,6 +285,10 @@ export class Network implements INetwork {
     this.networkProcessor.searchUnknownBlock(slotRoot, source, peer);
   }
 
+  searchUnknownEnvelope(slotRoot: SlotRootHex, source: BlockInputSource, peer?: PeerIdStr): void {
+    this.networkProcessor.searchUnknownEnvelope(slotRoot, source, peer);
+  }
+
   async reportPeer(peer: PeerIdStr, action: PeerAction, actionName: string): Promise<void> {
     return this.core.reportPeer(peer, action, actionName);
   }
@@ -621,7 +624,7 @@ export class Network implements INetwork {
   async sendDataColumnSidecarsByRange(
     peerId: PeerIdStr,
     request: fulu.DataColumnSidecarsByRangeRequest
-  ): Promise<fulu.DataColumnSidecar[]> {
+  ): Promise<DataColumnSidecar[]> {
     return collectMaxResponseTyped(
       this.sendReqRespRequest(peerId, ReqRespMethod.DataColumnSidecarsByRange, [Version.V1], request),
       request.count * request.columns.length,
@@ -632,7 +635,7 @@ export class Network implements INetwork {
   async sendDataColumnSidecarsByRoot(
     peerId: PeerIdStr,
     request: DataColumnSidecarsByRootRequest
-  ): Promise<fulu.DataColumnSidecar[]> {
+  ): Promise<DataColumnSidecar[]> {
     return collectMaxResponseTyped(
       this.sendReqRespRequest(peerId, ReqRespMethod.DataColumnSidecarsByRoot, [Version.V1], request),
       request.reduce((total, {columns}) => total + columns.length, 0),
@@ -812,7 +815,7 @@ export class Network implements INetwork {
     this.core.setTargetGroupCount(count);
   };
 
-  private onPublishDataColumns = (sidecars: DataColumnSidecars): Promise<number[]> => {
+  private onPublishDataColumns = (sidecars: DataColumnSidecar[]): Promise<number[]> => {
     return promiseAllMaybeAsync(sidecars.map((sidecar) => () => this.publishDataColumnSidecar(sidecar)));
   };
 

package/src/network/options.ts

@@ -55,7 +55,12 @@ 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"],
+  localMultiaddrs: [
+    "/ip4/0.0.0.0/udp/9001/quic-v1",
+    "/ip6/::/udp/9001/quic-v1",
+    "/ip4/0.0.0.0/tcp/9000",
+    "/ip6/::/tcp/9000",
+  ],
   bootMultiaddrs: [],
   /** disabled by default */
   discv5: null,
@@ -69,7 +74,7 @@ export const defaultNetworkOptions: NetworkOptions = {
   slotsToSubscribeBeforeAggregatorDuty: 2,
   // This will enable the light client server by default
   disableLightClientServer: false,
-  quic: false,
+  quic: true,
   tcp: true,
   // specific option for fulu
   //   - this is the same to TARGET_SUBNET_PEERS

package/src/network/processor/extractSlotRootFns.ts

@@ -1,23 +1,25 @@
-import {ForkName, isForkPostGloas} from "@lodestar/params";
+import {ForkName, ForkSeq} from "@lodestar/params";
 import {SlotOptionalRoot, SlotRootHex} from "@lodestar/types";
 import {
   getBeaconBlockRootFromDataColumnSidecarSerialized,
-  getBeaconBlockRootFromExecutionPayloadEnvelopeSerialized,
   getBlockRootFromBeaconAttestationSerialized,
+  getBlockRootFromPayloadAttestationMessageSerialized,
   getBlockRootFromSignedAggregateAndProofSerialized,
   getSlotFromBeaconAttestationSerialized,
   getSlotFromBlobSidecarSerialized,
   getSlotFromDataColumnSidecarSerialized,
   getSlotFromExecutionPayloadEnvelopeSerialized,
+  getSlotFromPayloadAttestationMessageSerialized,
   getSlotFromSignedAggregateAndProofSerialized,
   getSlotFromSignedBeaconBlockSerialized,
+  getSlotFromSignedExecutionPayloadBidSerialized,
 } from "../../util/sszBytes.js";
 import {GossipType} from "../gossip/index.js";
 import {ExtractSlotRootFns} from "./types.js";
 
 /**
  * Extract the slot and block root of a gossip message form serialized data.
- * Not applicable for all topics.
+ * Only do it for messages that have a slot and block root, and we want to await the block if the block root is not known.
  */
 export function createExtractBlockSlotRootFns(): ExtractSlotRootFns {
   return {
@@ -57,21 +59,45 @@ export function createExtractBlockSlotRootFns(): ExtractSlotRootFns {
     },
     [GossipType.data_column_sidecar]: (data: Uint8Array, fork: ForkName): SlotOptionalRoot | null => {
       const slot = getSlotFromDataColumnSidecarSerialized(data, fork);
+
       if (slot === null) {
         return null;
       }
 
-      const root = isForkPostGloas(fork) ? getBeaconBlockRootFromDataColumnSidecarSerialized(data) : null;
+      if (ForkSeq[fork] < ForkSeq.gloas) {
+        return {slot};
+      }
+
+      const root = getBeaconBlockRootFromDataColumnSidecarSerialized(data);
+      // null root means the message is invalid here and will be ignored in gossip handler later
+      // returning the slot here helps check the earliest permissable slot in the network processor
       return root !== null ? {slot, root} : {slot};
     },
-    [GossipType.execution_payload]: (data: Uint8Array): SlotRootHex | null => {
+    [GossipType.execution_payload]: (data: Uint8Array): SlotOptionalRoot | null => {
       const slot = getSlotFromExecutionPayloadEnvelopeSerialized(data);
-      const root = getBeaconBlockRootFromExecutionPayloadEnvelopeSerialized(data);
+      // Do not extract the root here; the network processor will extract it in the 2nd round to trigger block search without awaiting.
+      if (slot === null) {
+        return null;
+      }
+      return {slot};
+    },
+    [GossipType.payload_attestation_message]: (data: Uint8Array): SlotRootHex | null => {
+      const slot = getSlotFromPayloadAttestationMessageSerialized(data);
+      const root = getBlockRootFromPayloadAttestationMessageSerialized(data);
 
       if (slot === null || root === null) {
         return null;
       }
       return {slot, root};
     },
+    [GossipType.execution_payload_bid]: (data: Uint8Array): SlotOptionalRoot | null => {
+      const slot = getSlotFromSignedExecutionPayloadBidSerialized(data);
+
+      if (slot === null) {
+        return null;
+      }
+
+      return {slot};
+    },
   };
 }