chore: fix lints, types and unit tests in peerDAS

packages/beacon-node/src/chain/blocks/types.ts

@@ -1,6 +1,6 @@
 import type {ChainForkConfig} from "@lodestar/config";
 import type {DataAvailabilityStatus, MaybeValidExecutionStatus} from "@lodestar/fork-choice";
-import {type ForkPostDeneb, ForkSeq, ForkPreFulu, ForkPostFulu} from "@lodestar/params";
+import {type ForkPostDeneb, ForkPostFulu, ForkPreFulu, ForkSeq} from "@lodestar/params";
 import {type CachedBeaconStateAllForks, computeEpochAtSlot} from "@lodestar/state-transition";
 import type {ColumnIndex, RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
 

packages/beacon-node/src/chain/emitter.ts

@@ -4,7 +4,7 @@ import {StrictEventEmitter} from "strict-event-emitter-types";
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {phase0, fulu} from "@lodestar/types";
+import {fulu, phase0} from "@lodestar/types";
 
 /**
  * Important chain events that occur during normal chain operation.

packages/beacon-node/src/chain/interface.ts

@@ -31,6 +31,7 @@ import {IExecutionBuilder, IExecutionEngine} from "../execution/index.js";
 import {Metrics} from "../metrics/metrics.js";
 import {BufferPool} from "../util/bufferPool.js";
 import {IClock} from "../util/clock.js";
+import {CustodyConfig} from "../util/dataColumns.js";
 import {SerializedCache} from "../util/serializedCache.js";
 import {IArchiveStore} from "./archiveStore/interface.js";
 import {CheckpointBalancesCache} from "./balancesCache.js";
@@ -61,7 +62,6 @@ import {SeenAggregatedAttestations} from "./seenCache/seenAggregateAndProof.js";
 import {SeenAttestationDatas} from "./seenCache/seenAttestationData.js";
 import {SeenBlockAttesters} from "./seenCache/seenBlockAttesters.js";
 import {ShufflingCache} from "./shufflingCache.js";
-import {CustodyConfig} from "../util/dataColumns.js";
 
 export {BlockType, type AssembledBlockType};
 export {type ProposerPreparationData};

packages/beacon-node/src/chain/validation/dataColumnSidecar.ts

@@ -7,12 +7,12 @@ import {
 import {Root, Slot, deneb, fulu, ssz} from "@lodestar/types";
 import {toHex, verifyMerkleBranch} from "@lodestar/utils";
 
+import {Metrics} from "../../metrics/metrics.js";
 import {byteArrayEquals} from "../../util/bytes.js";
 import {ckzg} from "../../util/kzg.js";
 import {DataColumnSidecarErrorCode, DataColumnSidecarGossipError} from "../errors/dataColumnSidecarError.js";
 import {GossipAction} from "../errors/gossipValidation.js";
 import {IBeaconChain} from "../interface.js";
-import {Metrics} from "../../metrics/metrics.js";
 
 export async function validateGossipDataColumnSidecar(
   chain: IBeaconChain,

packages/beacon-node/src/network/core/networkCore.ts

@@ -21,6 +21,7 @@ import {Eth2Gossipsub, getCoreTopicsAtFork} from "../gossip/index.js";
 import {Libp2p} from "../interface.js";
 import {createNodeJsLibp2p} from "../libp2p/index.js";
 import {MetadataController} from "../metadata.js";
+import {NetworkConfig} from "../networkConfig.js";
 import {NetworkOptions} from "../options.js";
 import {PeerAction, PeerRpcScoreStore, PeerScoreStats} from "../peers/index.js";
 import {PeerManager} from "../peers/peerManager.js";
@@ -34,7 +35,6 @@ import {SyncnetsService} from "../subnets/syncnetsService.js";
 import {getConnectionsMap} from "../util.js";
 import {NetworkCoreMetrics, createNetworkCoreMetrics} from "./metrics.js";
 import {INetworkCore, MultiaddrStr, PeerIdStr} from "./types.js";
-import {NetworkConfig} from "../networkConfig.js";
 
 type Mods = {
   libp2p: Libp2p;

packages/beacon-node/src/network/network.ts

@@ -34,6 +34,7 @@ import {Metrics, RegistryMetricCreator} from "../metrics/index.js";
 import {IClock} from "../util/clock.js";
 import {CustodyConfig} from "../util/dataColumns.js";
 import {PeerIdStr, peerIdToString} from "../util/peerId.js";
+import {promiseAllMaybeAsync} from "../util/promises.js";
 import {BlobSidecarsByRootRequest} from "../util/types.js";
 import {INetworkCore, NetworkCore, WorkerNetworkCore} from "./core/index.js";
 import {INetworkEventBus, NetworkEvent, NetworkEventBus, NetworkEventData} from "./events.js";
@@ -55,7 +56,6 @@ import {
 import {collectSequentialBlocksInRange} from "./reqresp/utils/collectSequentialBlocksInRange.js";
 import {CommitteeSubscription, NodeId} from "./subnets/index.js";
 import {isPublishToZeroPeersError} from "./util.js";
-import {promiseAllMaybeAsync} from "../util/promises.js";
 
 type NetworkModules = {
   opts: NetworkOptions;

packages/beacon-node/src/network/peers/discover.ts

@@ -8,19 +8,19 @@ import {CustodyIndex, SubnetID} from "@lodestar/types";
 import {pruneSetToMax, sleep} from "@lodestar/utils";
 import {bytesToInt} from "@lodestar/utils";
 import {Multiaddr} from "@multiformats/multiaddr";
+import {IClock} from "../../util/clock.js";
 import {getCustodyGroups, getDataColumns} from "../../util/dataColumns.js";
 import {NetworkCoreMetrics} from "../core/metrics.js";
 import {Discv5Worker} from "../discv5/index.js";
 import {LodestarDiscv5Opts} from "../discv5/types.js";
 import {Libp2p} from "../interface.js";
 import {ENRKey, SubnetType} from "../metadata.js";
+import {NetworkConfig} from "../networkConfig.js";
 import {NodeId, computeNodeId} from "../subnets/interface.js";
 import {getConnectionsMap, prettyPrintPeerId} from "../util.js";
 import {IPeerRpcScoreStore, ScoreState} from "./score/index.js";
 import {deserializeEnrSubnets, zeroAttnets, zeroSyncnets} from "./utils/enrSubnetsDeserialize.js";
 import {type GroupQueries} from "./utils/prioritizePeers.js";
-import {IClock} from "../../util/clock.js";
-import {NetworkConfig} from "../networkConfig.js";
 
 /** Max number of cached ENRs after discovering a good peer */
 const MAX_CACHED_ENRS = 100;
@@ -253,7 +253,7 @@ export class PeerDiscovery {
       group: for (const [group, maxPeersToConnect] of groupRequests) {
         let cachedENRsInGroup = 0;
         for (const cachedENR of cachedENRsReverse) {
-          if (cachedENR.peerCustodyGroups && cachedENR.peerCustodyGroups.includes(group)) {
+          if (cachedENR.peerCustodyGroups?.includes(group)) {
             cachedENRsToDial.set(cachedENR.peerId.toString(), cachedENR);
 
             if (++cachedENRsInGroup >= maxPeersToConnect) {

packages/beacon-node/src/network/peers/peerManager.ts

@@ -14,23 +14,23 @@ import {INetworkEventBus, NetworkEvent, NetworkEventData} from "../events.js";
 import {Eth2Gossipsub} from "../gossip/gossipsub.js";
 import {Libp2p} from "../interface.js";
 import {SubnetType} from "../metadata.js";
+import {NetworkConfig} from "../networkConfig.js";
 import {ReqRespMethod} from "../reqresp/ReqRespBeaconNode.js";
 import {StatusCache} from "../statusCache.js";
 import {NodeId, SubnetsService, computeNodeId} from "../subnets/index.js";
 import {getConnection, getConnectionsMap, prettyPrintPeerId} from "../util.js";
 import {ClientKind, getKnownClientFromAgentVersion} from "./client.js";
 import {PeerDiscovery, SubnetDiscvQueryMs} from "./discover.js";
+import {PeerData, PeersData} from "./peersData.js";
 import {IPeerRpcScoreStore, PeerAction, PeerScoreStats, ScoreState, updateGossipsubScores} from "./score/index.js";
-import {PeersData, PeerData} from "./peersData.js";
 import {
+  PrioritizePeersOpts,
   assertPeerRelevance,
   getConnectedPeerIds,
   hasSomeConnectedPeer,
   prioritizePeers,
   renderIrrelevantPeerType,
-  PrioritizePeersOpts,
 } from "./utils/index.js";
-import {NetworkConfig} from "../networkConfig.js";
 
 /** heartbeat performs regular updates such as updating reputations and performing discovery requests */
 const HEARTBEAT_INTERVAL_MS = 30 * 1000;

packages/beacon-node/src/network/peers/utils/prioritizePeers.ts

@@ -91,7 +91,7 @@ export function prioritizePeers(
   }[],
   activeAttnets: RequestedSubnet[],
   activeSyncnets: RequestedSubnet[],
-  samplingGroups: CustodyIndex[] = [],
+  samplingGroups: CustodyIndex[] | undefined,
   opts: PrioritizePeersOpts,
   metrics: NetworkCoreMetrics | null
 ): {
@@ -162,7 +162,7 @@ function requestSubnetPeers(
   connectedPeers: PeerInfo[],
   activeAttnets: RequestedSubnet[],
   activeSyncnets: RequestedSubnet[],
-  samplingGroups: CustodyIndex[] = [],
+  samplingGroups: CustodyIndex[] | undefined,
   opts: PrioritizePeersOpts,
   metrics: NetworkCoreMetrics | null
 ): {
@@ -241,7 +241,7 @@ function requestSubnetPeers(
     }
   }
 
-  for (const group of samplingGroups) {
+  for (const group of samplingGroups ?? []) {
     const peersInGroup = peersPerGroup.get(group) ?? 0;
     metrics?.peerCountPerSamplingGroup.set({group}, peersInGroup);
     if (peersInGroup < targetGroupPeers) {

packages/beacon-node/src/network/reqresp/beaconBlocksMaybeBlobsByRange.ts

@@ -260,12 +260,8 @@ export function matchBlockWithDataColumns(
       throw Error(`Invalid block forkSeq=${forkSeq} < ForSeq.fulu for matchBlockWithDataColumns`);
     }
     const dataColumnSidecars: fulu.DataColumnSidecar[] = [];
-    let dataColumnSidecar: fulu.DataColumnSidecar;
-    while (
-      (dataColumnSidecar = allDataColumnSidecars[dataColumnSideCarIndex])?.signedBlockHeader.message.slot ===
-      block.data.message.slot
-    ) {
-      dataColumnSidecars.push(dataColumnSidecar);
+    while (allDataColumnSidecars[dataColumnSideCarIndex]?.signedBlockHeader.message.slot === block.data.message.slot) {
+      dataColumnSidecars.push(allDataColumnSidecars[dataColumnSideCarIndex]);
       lastMatchedSlot = block.data.message.slot;
       dataColumnSideCarIndex++;
     }

packages/beacon-node/src/network/reqresp/beaconBlocksMaybeBlobsByRoot.ts

@@ -522,88 +522,88 @@ export async function unavailableBeaconBlobsByRootPostFulu(
     resolveAvailability(blockData);
     opts.metrics?.syncUnknownBlock.resolveAvailabilitySource.inc({source: BlockInputAvailabilitySource.UNKNOWN_SYNC});
     return getBlockInput.availableData(config, block, BlockSource.byRoot, blockData);
-  } else {
-    const sampledColumns = network.custodyConfig.sampledColumns;
-    let neededColumns = sampledColumns.reduce((acc, elem) => {
-      if (dataColumnsCache.get(elem) === undefined) {
-        acc.push(elem);
-      }
-      return acc;
-    }, [] as number[]);
+  }
 
-    const peerColumns = network.getConnectedPeerCustody(peerId);
+  const sampledColumns = network.custodyConfig.sampledColumns;
+  let neededColumns = sampledColumns.reduce((acc, elem) => {
+    if (dataColumnsCache.get(elem) === undefined) {
+      acc.push(elem);
+    }
+    return acc;
+  }, [] as number[]);
 
-    // get match
-    const columns = peerColumns.reduce((acc, elem) => {
-      if (neededColumns.includes(elem)) {
-        acc.push(elem);
-      }
-      return acc;
-    }, [] as number[]);
+  const peerColumns = network.getConnectedPeerCustody(peerId);
 
-    // this peer can't help fetching columns for this block
-    if (unavailableBlockInput.block !== null && columns.length === 0 && neededColumns.length > 0) {
-      return unavailableBlockInput;
+  // get match
+  const columns = peerColumns.reduce((acc, elem) => {
+    if (neededColumns.includes(elem)) {
+      acc.push(elem);
     }
+    return acc;
+  }, [] as number[]);
 
-    for (const columnIndex of columns) {
-      dataColumnIdentifiers.push({blockRoot, index: columnIndex});
-    }
+  // this peer can't help fetching columns for this block
+  if (unavailableBlockInput.block !== null && columns.length === 0 && neededColumns.length > 0) {
+    return unavailableBlockInput;
+  }
 
-    let allDataColumnSidecars: fulu.DataColumnSidecar[];
-    if (dataColumnIdentifiers.length > 0) {
-      allDataColumnSidecars = await network.sendDataColumnSidecarsByRoot(peerId, dataColumnIdentifiers);
-    } else {
-      allDataColumnSidecars = [];
-    }
+  for (const columnIndex of columns) {
+    dataColumnIdentifiers.push({blockRoot, index: columnIndex});
+  }
 
-    const logCtx = {
-      slot: block.message.slot,
-      requestedColumns: columns.join(","),
-      respondedColumns: allDataColumnSidecars.map((dcs) => dcs.index).join(","),
-      peerClient,
-    };
-
-    // the same to matchBlockWithDataColumns() without expecting requested data columns = responded data columns
-    // because at gossip time peer may not have enough column to return
-    for (const dataColumnSidecar of allDataColumnSidecars) {
-      dataColumnsCache.set(dataColumnSidecar.index, {
-        dataColumn: dataColumnSidecar,
-        // TODO: req/resp should return bytes here
-        dataColumnBytes: null,
-      });
-    }
+  let allDataColumnSidecars: fulu.DataColumnSidecar[];
+  if (dataColumnIdentifiers.length > 0) {
+    allDataColumnSidecars = await network.sendDataColumnSidecarsByRoot(peerId, dataColumnIdentifiers);
+  } else {
+    allDataColumnSidecars = [];
+  }
 
-    // reevaluate needeColumns and resolve availability if possible
-    neededColumns = sampledColumns.reduce((acc, elem) => {
-      if (dataColumnsCache.get(elem) === undefined) {
-        acc.push(elem);
-      }
-      return acc;
-    }, [] as number[]);
+  const logCtx = {
+    slot: block.message.slot,
+    requestedColumns: columns.join(","),
+    respondedColumns: allDataColumnSidecars.map((dcs) => dcs.index).join(","),
+    peerClient,
+  };
 
-    if (neededColumns.length === 0) {
-      const {dataColumns, dataColumnsBytes} = getBlockInputDataColumns(
-        (cachedData as CachedDataColumns).dataColumnsCache,
-        sampledColumns
-      );
-
-      // don't forget to resolve availability as the block may be stuck in availability wait
-      const blockData = {
-        fork: config.getForkName(block.message.slot),
-        dataColumns,
-        dataColumnsBytes,
-        dataColumnsSource: DataColumnsSource.byRoot,
-      } as BlockInputDataColumns;
-      resolveAvailability(blockData);
-      opts.logger?.verbose(
-        "unavailableBeaconBlobsByRootPostFulu: Resolved availability for block with all data columns",
-        logCtx
-      );
-      return getBlockInput.availableData(config, block, BlockSource.byRoot, blockData);
-    } else {
-      opts.logger?.verbose("unavailableBeaconBlobsByRootPostFulu: Still missing data columns for block", logCtx);
-      return getBlockInput.dataPromise(config, block, BlockSource.byRoot, cachedData);
+  // the same to matchBlockWithDataColumns() without expecting requested data columns = responded data columns
+  // because at gossip time peer may not have enough column to return
+  for (const dataColumnSidecar of allDataColumnSidecars) {
+    dataColumnsCache.set(dataColumnSidecar.index, {
+      dataColumn: dataColumnSidecar,
+      // TODO: req/resp should return bytes here
+      dataColumnBytes: null,
+    });
+  }
+
+  // reevaluate needeColumns and resolve availability if possible
+  neededColumns = sampledColumns.reduce((acc, elem) => {
+    if (dataColumnsCache.get(elem) === undefined) {
+      acc.push(elem);
     }
+    return acc;
+  }, [] as number[]);
+
+  if (neededColumns.length === 0) {
+    const {dataColumns, dataColumnsBytes} = getBlockInputDataColumns(
+      (cachedData as CachedDataColumns).dataColumnsCache,
+      sampledColumns
+    );
+
+    // don't forget to resolve availability as the block may be stuck in availability wait
+    const blockData = {
+      fork: config.getForkName(block.message.slot),
+      dataColumns,
+      dataColumnsBytes,
+      dataColumnsSource: DataColumnsSource.byRoot,
+    } as BlockInputDataColumns;
+    resolveAvailability(blockData);
+    opts.logger?.verbose(
+      "unavailableBeaconBlobsByRootPostFulu: Resolved availability for block with all data columns",
+      logCtx
+    );
+    return getBlockInput.availableData(config, block, BlockSource.byRoot, blockData);
   }
+
+  opts.logger?.verbose("unavailableBeaconBlobsByRootPostFulu: Still missing data columns for block", logCtx);
+  return getBlockInput.dataPromise(config, block, BlockSource.byRoot, cachedData);
 }

packages/beacon-node/src/node/nodejs.ts

@@ -180,7 +180,7 @@ export class BeaconNode {
         config,
         anchorState,
         logger.child({module: LoggerModule.vmon}),
-        metricsRegistries,
+        metricsRegistries
       );
       initBeaconMetrics(metrics, anchorState);
       // Since the db is instantiated before this, metrics must be injected manually afterwards

packages/beacon-node/src/util/blobs.ts

@@ -3,8 +3,8 @@ import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {ChainForkConfig} from "@lodestar/config";
 import {
   ForkAll,
-  ForkPostDeneb,
   ForkName,
+  ForkPostDeneb,
   KZG_COMMITMENTS_GINDEX,
   KZG_COMMITMENT_GINDEX0,
   NUMBER_OF_COLUMNS,

packages/beacon-node/test/e2e/network/onWorker/dataSerialization.test.ts

@@ -151,6 +151,8 @@ describe("data serialization through worker boundary", () => {
     scrapeMetrics: [],
     writeProfile: [0, ""],
     writeDiscv5Profile: [0, ""],
+    setTargetGroupCount: [4],
+    setAdvertisedGroupCount: [4],
   };
 
   const lodestarPeer: routes.lodestar.LodestarNodePeer = {
@@ -214,6 +216,8 @@ describe("data serialization through worker boundary", () => {
     scrapeMetrics: "test-metrics",
     writeProfile: "",
     writeDiscv5Profile: "",
+    setAdvertisedGroupCount: null,
+    setTargetGroupCount: null,
   };
 
   type TestCase = {id: string; data: unknown; shouldFail?: boolean};