@lodestar/beacon-node 1.41.0-dev.e1d339886d → 1.41.0-dev.e6c853da0e

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.41.0-dev.e1d339886d",
+  "version": "1.41.0-dev.e6c853da0e",
   "type": "module",
   "exports": {
     ".": {
@@ -110,10 +110,9 @@
   "dependencies": {
     "@chainsafe/as-sha256": "^1.2.0",
     "@chainsafe/blst": "^2.2.0",
-    "@chainsafe/discv5": "^11.0.4",
-    "@chainsafe/enr": "^5.0.1",
-    "@chainsafe/libp2p-gossipsub": "^14.1.2",
-    "@chainsafe/libp2p-noise": "^16.1.5",
+    "@chainsafe/discv5": "^12.0.0",
+    "@chainsafe/enr": "^6.0.0",
+    "@chainsafe/libp2p-noise": "^17.0.0",
     "@chainsafe/persistent-merkle-tree": "^1.2.1",
     "@chainsafe/prometheus-gc-stats": "^1.0.0",
     "@chainsafe/pubkey-index-map": "^3.0.0",
@@ -125,39 +124,38 @@
     "@fastify/cors": "^10.0.1",
     "@fastify/swagger": "^9.0.0",
     "@fastify/swagger-ui": "^5.0.1",
-    "@libp2p/bootstrap": "^11.0.32",
-    "@libp2p/crypto": "^5.0.15",
-    "@libp2p/identify": "^3.0.27",
-    "@libp2p/interface": "^2.7.0",
-    "@libp2p/mdns": "^11.0.32",
-    "@libp2p/mplex": "^11.0.32",
-    "@libp2p/peer-id": "^5.1.0",
-    "@libp2p/prometheus-metrics": "^4.3.15",
-    "@libp2p/tcp": "^10.1.8",
-    "@lodestar/api": "^1.41.0-dev.e1d339886d",
-    "@lodestar/config": "^1.41.0-dev.e1d339886d",
-    "@lodestar/db": "^1.41.0-dev.e1d339886d",
-    "@lodestar/fork-choice": "^1.41.0-dev.e1d339886d",
-    "@lodestar/light-client": "^1.41.0-dev.e1d339886d",
-    "@lodestar/logger": "^1.41.0-dev.e1d339886d",
-    "@lodestar/params": "^1.41.0-dev.e1d339886d",
-    "@lodestar/reqresp": "^1.41.0-dev.e1d339886d",
-    "@lodestar/state-transition": "^1.41.0-dev.e1d339886d",
-    "@lodestar/types": "^1.41.0-dev.e1d339886d",
-    "@lodestar/utils": "^1.41.0-dev.e1d339886d",
-    "@lodestar/validator": "^1.41.0-dev.e1d339886d",
-    "@multiformats/multiaddr": "^12.1.3",
-    "datastore-core": "^10.0.2",
-    "datastore-fs": "^10.0.6",
-    "datastore-level": "^11.0.3",
+    "@libp2p/bootstrap": "^12.0.13",
+    "@libp2p/crypto": "^5.1.13",
+    "@libp2p/gossipsub": "^15.0.14",
+    "@libp2p/identify": "^4.0.12",
+    "@libp2p/interface": "^3.1.0",
+    "@libp2p/mdns": "^12.0.13",
+    "@libp2p/mplex": "^12.0.13",
+    "@libp2p/peer-id": "^6.0.4",
+    "@libp2p/prometheus-metrics": "^5.0.13",
+    "@libp2p/tcp": "^11.0.12",
+    "@lodestar/api": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/config": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/db": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/fork-choice": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/light-client": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/logger": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/params": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/reqresp": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/state-transition": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/types": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/utils": "^1.41.0-dev.e6c853da0e",
+    "@lodestar/validator": "^1.41.0-dev.e6c853da0e",
+    "@multiformats/multiaddr": "^13.0.1",
+    "datastore-core": "^11.0.2",
+    "datastore-fs": "^11.0.2",
+    "datastore-level": "^12.0.2",
     "deepmerge": "^4.3.1",
-    "fastify": "^5.7.4",
-    "interface-datastore": "^8.3.0",
-    "it-all": "^3.0.4",
-    "it-pipe": "^3.0.1",
+    "fastify": "^5.8.1",
+    "interface-datastore": "^9.0.2",
     "jwt-simple": "0.5.6",
-    "libp2p": "2.9.0",
-    "multiformats": "^11.0.1",
+    "libp2p": "3.1.5",
+    "multiformats": "^13.4.2",
     "prom-client": "^15.1.0",
     "qs": "^6.11.1",
     "strict-event-emitter-types": "^2.0.0",
@@ -167,14 +165,13 @@
   },
   "devDependencies": {
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@libp2p/interface-internal": "^2.3.18",
-    "@libp2p/logger": "^5.1.21",
-    "@lodestar/spec-test-util": "^1.41.0-dev.e1d339886d",
+    "@libp2p/interface-internal": "^3.0.12",
+    "@libp2p/logger": "^6.2.2",
+    "@libp2p/utils": "^7.0.12",
+    "@lodestar/spec-test-util": "^1.41.0-dev.e6c853da0e",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
-    "it-drain": "^3.0.3",
-    "it-pair": "^2.0.6",
     "js-yaml": "^4.1.0",
     "rewiremock": "^3.14.5",
     "rimraf": "^4.4.1",
@@ -188,5 +185,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "9d2b083b692d36e939c121668ff80e7a0c0e538b"
+  "gitHead": "d5e94a7618eff50c0c78b35bc423ae4fa481ff0e"
 }

package/src/api/impl/beacon/blocks/index.ts

@@ -1,6 +1,8 @@
 import {routes} from "@lodestar/api";
 import {ApiError, ApplicationMethods} from "@lodestar/api/server";
+import {PayloadStatus} from "@lodestar/fork-choice";
 import {
+  BUILDER_INDEX_SELF_BUILD,
   ForkPostBellatrix,
   ForkPostFulu,
   ForkPreGloas,
@@ -27,6 +29,7 @@ import {
   WithOptionalBytes,
   deneb,
   fulu,
+  gloas,
   isDenebBlockContents,
   sszTypesFor,
 } from "@lodestar/types";
@@ -42,6 +45,7 @@ import {
   ProduceFullBellatrix,
   ProduceFullDeneb,
   ProduceFullFulu,
+  ProduceFullGloas,
 } from "../../../../chain/produceBlock/index.js";
 import {validateGossipBlock} from "../../../../chain/validation/block.js";
 import {OpSource} from "../../../../chain/validatorMonitor.js";
@@ -51,7 +55,7 @@ import {
   kzgCommitmentToVersionedHash,
   reconstructBlobs,
 } from "../../../../util/blobs.js";
-import {getDataColumnSidecarsFromBlock} from "../../../../util/dataColumns.js";
+import {getDataColumnSidecarsForGloas, getDataColumnSidecarsFromBlock} from "../../../../util/dataColumns.js";
 import {isOptimisticBlock} from "../../../../util/forkChoice.js";
 import {kzg} from "../../../../util/kzg.js";
 import {promiseAllMaybeAsync} from "../../../../util/promises.js";
@@ -93,6 +97,7 @@ export function getBeaconBlockApi({
     const fork = config.getForkName(slot);
     const blockRoot = toRootHex(chain.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(signedBlock.message));
 
+    // TODO GLOAS: handle new BlockInput type
     const blockForImport = chain.seenBlockInputCache.getByBlock({
       block: signedBlock,
       source: BlockInputSource.api,
@@ -201,7 +206,7 @@ export function getBeaconBlockApi({
       case routes.beacon.BroadcastValidation.consensus: {
         // check if this beacon node produced the block else run validations
         if (!blockLocallyProduced) {
-          const parentBlock = chain.forkChoice.getBlock(signedBlock.message.parentRoot);
+          const parentBlock = chain.forkChoice.getBlockDefaultStatus(signedBlock.message.parentRoot);
           if (parentBlock === null) {
             chain.emitter.emit(ChainEvent.unknownParent, {
               blockInput: blockForImport,
@@ -309,7 +314,9 @@ export function getBeaconBlockApi({
     ];
     const sentPeersArr = await promiseAllMaybeAsync<number | void>(publishPromises);
 
-    if (isForkPostFulu(fork)) {
+    if (isForkPostGloas(fork)) {
+      // After gloas, data columns are not published with the block but when publishing the execution payload envelope
+    } else if (isForkPostFulu(fork)) {
       let columnsPublishedWithZeroPeers = 0;
       // sent peers per topic are logged in network.publishGossip(), here we only track metrics for it
       // starting from fulu, we have to push to 128 subnets so need to make sure we have enough sent peers per topic
@@ -632,6 +639,143 @@ export function getBeaconBlockApi({
       await publishBlock(args, context, opts);
     },
 
+    async publishExecutionPayloadEnvelope({signedExecutionPayloadEnvelope}) {
+      const seenTimestampSec = Date.now() / 1000;
+      const envelope = signedExecutionPayloadEnvelope.message;
+      const slot = envelope.slot;
+      const fork = config.getForkName(slot);
+      const blockRootHex = toRootHex(envelope.beaconBlockRoot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `publishExecutionPayloadEnvelope not supported for pre-gloas fork=${fork}`);
+      }
+
+      // TODO GLOAS: review checks, do we want to implement `broadcast_validation`?
+      const block = chain.forkChoice.getBlockHex(blockRootHex, PayloadStatus.EMPTY);
+      if (block === null) {
+        throw new ApiError(404, `Block not found for beacon block root ${blockRootHex}`);
+      }
+      if (block.slot !== slot) {
+        throw new ApiError(400, `Envelope slot ${slot} does not match block slot ${block.slot}`);
+      }
+
+      const isSelfBuild = envelope.builderIndex === BUILDER_INDEX_SELF_BUILD;
+      let dataColumnSidecars: gloas.DataColumnSidecars = [];
+
+      if (isSelfBuild) {
+        // For self-builds, construct and publish data column sidecars from cached block production data
+        const cachedResult = chain.blockProductionCache.get(blockRootHex) as ProduceFullGloas | undefined;
+        if (cachedResult === undefined) {
+          throw new ApiError(404, `No cached block production result found for block root ${blockRootHex}`);
+        }
+        if (!isForkPostGloas(cachedResult.fork)) {
+          throw new ApiError(400, `Cached block production result is for pre-gloas fork=${cachedResult.fork}`);
+        }
+        if (cachedResult.type !== BlockType.Full) {
+          throw new ApiError(400, "Cached block production result is not full block");
+        }
+
+        if (cachedResult.cells && cachedResult.blobsBundle.commitments.length > 0) {
+          const cellsAndProofs = cachedResult.cells.map((rowCells, rowIndex) => ({
+            cells: rowCells,
+            proofs: cachedResult.blobsBundle.proofs.slice(
+              rowIndex * NUMBER_OF_COLUMNS,
+              (rowIndex + 1) * NUMBER_OF_COLUMNS
+            ),
+          }));
+
+          dataColumnSidecars = getDataColumnSidecarsForGloas(slot, envelope.beaconBlockRoot, cellsAndProofs);
+        }
+      } else {
+        // TODO GLOAS: will this api be used by builders or only for self-building?
+      }
+
+      // TODO GLOAS: Verify execution payload envelope signature
+      // For self-builds, the proposer signs with their own validator key
+      // For external builders, verify using the builder's registered pubkey
+      // Use verify_execution_payload_envelope_signature(state, signed_envelope)
+
+      // TODO GLOAS: Process execution payload via state transition
+      // Call process_execution_payload(state, signed_envelope, execution_engine)
+
+      // TODO GLOAS: Update fork choice with the execution payload
+      // Call on_execution_payload(store, signed_envelope) to update fork choice state
+
+      // TODO GLOAS: Add envelope and data columns to block input via seenBlockInputCache
+      // and trigger block import (Gloas block import requires both beacon block and envelope)
+
+      const valLogMeta = {
+        slot,
+        blockRoot: blockRootHex,
+        builderIndex: envelope.builderIndex,
+        isSelfBuild,
+        dataColumns: dataColumnSidecars.length,
+      };
+
+      // If called near a slot boundary (e.g. late in slot N-1), hold briefly so gossip aligns with slot N.
+      const msToBlockSlot = computeTimeAtSlot(config, slot, chain.genesisTime) * 1000 - Date.now();
+      if (msToBlockSlot <= MAX_API_CLOCK_DISPARITY_MS && msToBlockSlot > 0) {
+        await sleep(msToBlockSlot);
+      }
+
+      const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
+      metrics?.gossipExecutionPayloadEnvelope.elapsedTimeTillReceived.observe({source: OpSource.api}, delaySec);
+
+      chain.logger.info("Publishing execution payload envelope", valLogMeta);
+
+      // Publish envelope and data columns
+      const publishPromises = [
+        // Gossip the signed execution payload envelope first
+        () => network.publishSignedExecutionPayloadEnvelope(signedExecutionPayloadEnvelope),
+        // For self-builds, publish all data column sidecars
+        ...dataColumnSidecars.map((dataColumnSidecar) => () => network.publishDataColumnSidecar(dataColumnSidecar)),
+      ];
+
+      const sentPeersArr = await promiseAllMaybeAsync<number | void>(publishPromises);
+
+      // Track metrics for data column publishing
+      if (dataColumnSidecars.length > 0) {
+        let columnsPublishedWithZeroPeers = 0;
+        // Skip first entry (envelope), track data columns
+        for (let i = 1; i < sentPeersArr.length; i++) {
+          const sentPeers = sentPeersArr[i] as number;
+          metrics?.dataColumns.sentPeersPerSubnet.observe(sentPeers);
+          if (sentPeers === 0) {
+            columnsPublishedWithZeroPeers++;
+          }
+        }
+        if (columnsPublishedWithZeroPeers > 0) {
+          chain.logger.warn("Published data columns to 0 peers, increased risk of reorg", {
+            slot,
+            blockRoot: blockRootHex,
+            columns: columnsPublishedWithZeroPeers,
+          });
+        }
+
+        metrics?.dataColumns.bySource.inc({source: BlockInputSource.api}, dataColumnSidecars.length);
+
+        if (chain.emitter.listenerCount(routes.events.EventType.dataColumnSidecar)) {
+          // TODO GLOAS: revisit this, we likely don't wanna emit KZG commitments anymore
+          const cachedResult = chain.blockProductionCache.get(blockRootHex) as ProduceFullGloas | undefined;
+          const kzgCommitments = cachedResult?.blobsBundle.commitments.map(toHex) ?? [];
+          for (const dataColumnSidecar of dataColumnSidecars) {
+            chain.emitter.emit(routes.events.EventType.dataColumnSidecar, {
+              blockRoot: blockRootHex,
+              slot,
+              index: dataColumnSidecar.index,
+              kzgCommitments,
+            });
+          }
+        }
+      }
+
+      chain.logger.info("Published execution payload envelope", {
+        ...valLogMeta,
+        delaySec,
+        sentPeers: (sentPeersArr[0] as number) ?? 0,
+      });
+    },
+
     async getBlobSidecars({blockId, indices}) {
       assertUniqueItems(indices, "Duplicate indices provided");
 

package/src/api/impl/beacon/state/index.ts

@@ -95,14 +95,14 @@ export function getBeaconStateApi({
       const {state, executionOptimistic, finalized} = await getState(stateId);
       const currentEpoch = getCurrentEpoch(state);
       const {validators, balances} = state; // Get the validators sub tree once for all the loop
-      const {pubkey2index} = chain;
+      const {pubkeyCache} = chain;
 
       const validatorResponses: routes.beacon.ValidatorResponse[] = [];
       if (validatorIds.length) {
         assertUniqueItems(validatorIds, "Duplicate validator IDs provided");
 
         for (const id of validatorIds) {
-          const resp = getStateValidatorIndex(id, state, pubkey2index);
+          const resp = getStateValidatorIndex(id, state, pubkeyCache);
           if (resp.valid) {
             const validatorIndex = resp.validatorIndex;
             const validator = validators.getReadonly(validatorIndex);
@@ -127,7 +127,7 @@ export function getBeaconStateApi({
       if (statuses.length) {
         assertUniqueItems(statuses, "Duplicate statuses provided");
 
-        const validatorsByStatus = filterStateValidatorsByStatus(statuses, state, pubkey2index, currentEpoch);
+        const validatorsByStatus = filterStateValidatorsByStatus(statuses, state, pubkeyCache, currentEpoch);
         return {
           data: validatorsByStatus,
           meta: {executionOptimistic, finalized},
@@ -154,7 +154,7 @@ export function getBeaconStateApi({
 
     async postStateValidatorIdentities({stateId, validatorIds = []}) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const {pubkey2index} = chain;
+      const {pubkeyCache} = chain;
 
       let validatorIdentities: routes.beacon.ValidatorIdentities;
 
@@ -163,7 +163,7 @@ export function getBeaconStateApi({
 
         validatorIdentities = [];
         for (const id of validatorIds) {
-          const resp = getStateValidatorIndex(id, state, pubkey2index);
+          const resp = getStateValidatorIndex(id, state, pubkeyCache);
           if (resp.valid) {
             const index = resp.validatorIndex;
             const {pubkey, activationEpoch} = state.validators.getReadonly(index);
@@ -187,9 +187,9 @@ export function getBeaconStateApi({
 
     async getStateValidator({stateId, validatorId}) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const {pubkey2index} = chain;
+      const {pubkeyCache} = chain;
 
-      const resp = getStateValidatorIndex(validatorId, state, pubkey2index);
+      const resp = getStateValidatorIndex(validatorId, state, pubkeyCache);
       if (!resp.valid) {
         throw new ApiError(resp.code, resp.reason);
       }
@@ -214,7 +214,7 @@ export function getBeaconStateApi({
 
         const balances: routes.beacon.ValidatorBalance[] = [];
         for (const id of validatorIds) {
-          const resp = getStateValidatorIndex(id, state, chain.pubkey2index);
+          const resp = getStateValidatorIndex(id, state, chain.pubkeyCache);
 
           if (resp.valid) {
             balances.push({

package/src/api/impl/beacon/state/utils.ts

@@ -1,9 +1,17 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex, IForkChoice} from "@lodestar/fork-choice";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {BeaconStateAllForks, CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {BLSPubkey, Epoch, RootHex, Slot, ValidatorIndex, getValidatorStatus, phase0} from "@lodestar/types";
+import {BeaconStateAllForks, CachedBeaconStateAllForks, PubkeyCache} from "@lodestar/state-transition";
+import {
+  BLSPubkey,
+  Epoch,
+  RootHex,
+  Slot,
+  ValidatorIndex,
+  getValidatorStatus,
+  mapToGeneralStatus,
+  phase0,
+} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../../chain/index.js";
 import {ApiError, ValidationError} from "../../errors.js";
@@ -65,28 +73,6 @@ export async function getStateResponseWithRegen(
   return res;
 }
 
-type GeneralValidatorStatus = "active" | "pending" | "exited" | "withdrawal";
-
-function mapToGeneralStatus(subStatus: routes.beacon.ValidatorStatus): GeneralValidatorStatus {
-  switch (subStatus) {
-    case "active_ongoing":
-    case "active_exiting":
-    case "active_slashed":
-      return "active";
-    case "pending_initialized":
-    case "pending_queued":
-      return "pending";
-    case "exited_slashed":
-    case "exited_unslashed":
-      return "exited";
-    case "withdrawal_possible":
-    case "withdrawal_done":
-      return "withdrawal";
-    default:
-      throw new Error(`Unknown substatus: ${subStatus}`);
-  }
-}
-
 export function toValidatorResponse(
   index: ValidatorIndex,
   validator: phase0.Validator,
@@ -104,7 +90,7 @@ export function toValidatorResponse(
 export function filterStateValidatorsByStatus(
   statuses: string[],
   state: BeaconStateAllForks,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   currentEpoch: Epoch
 ): routes.beacon.ValidatorResponse[] {
   const responses: routes.beacon.ValidatorResponse[] = [];
@@ -115,7 +101,7 @@ export function filterStateValidatorsByStatus(
     const validatorStatus = getValidatorStatus(validator, currentEpoch);
     const generalStatus = mapToGeneralStatus(validatorStatus);
 
-    const resp = getStateValidatorIndex(validator.pubkey, state, pubkey2index);
+    const resp = getStateValidatorIndex(validator.pubkey, state, pubkeyCache);
     if (resp.valid && (statusSet.has(validatorStatus) || statusSet.has(generalStatus))) {
       responses.push(
         toValidatorResponse(resp.validatorIndex, validator, state.balances.get(resp.validatorIndex), currentEpoch)
@@ -132,7 +118,7 @@ type StateValidatorIndexResponse =
 export function getStateValidatorIndex(
   id: routes.beacon.ValidatorId | BLSPubkey,
   state: BeaconStateAllForks,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: PubkeyCache
 ): StateValidatorIndexResponse {
   if (typeof id === "string") {
     // mutate `id` and fallthrough to below
@@ -160,7 +146,7 @@ export function getStateValidatorIndex(
   }
 
   // typeof id === Uint8Array
-  const validatorIndex = pubkey2index.get(id);
+  const validatorIndex = pubkeyCache.getIndex(id);
   if (validatorIndex === null) {
     return {valid: false, code: 404, reason: "Validator pubkey not found in state"};
   }

package/src/api/impl/debug/index.ts

@@ -1,9 +1,10 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ExecutionStatus} from "@lodestar/fork-choice";
-import {ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
-import {BeaconState, deneb, fulu, sszTypesFor} from "@lodestar/types";
+import {ForkPostDeneb, ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {BeaconState, DataColumnSidecars, type SignedBeaconBlock, sszTypesFor} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
+import {getBlobKzgCommitments} from "../../../util/dataColumns.js";
 import {isOptimisticBlock} from "../../../util/forkChoice.js";
 import {getStateSlotFromBytes} from "../../../util/multifork.js";
 import {getBlockResponse} from "../beacon/blocks/utils.js";
@@ -42,6 +43,7 @@ export function getDebugApi({
             validity: (() => {
               switch (node.executionStatus) {
                 case ExecutionStatus.Valid:
+                case ExecutionStatus.PayloadSeparated:
                   return "valid";
                 case ExecutionStatus.Invalid:
                   return "invalid";
@@ -96,10 +98,10 @@ export function getDebugApi({
       const fork = config.getForkName(block.message.slot);
       const blockRoot = sszTypesFor(fork).BeaconBlock.hashTreeRoot(block.message);
 
-      let dataColumnSidecars: fulu.DataColumnSidecars;
+      let dataColumnSidecars: DataColumnSidecars;
 
       const blobCount = isForkPostDeneb(fork)
-        ? (block.message.body as deneb.BeaconBlockBody).blobKzgCommitments.length
+        ? getBlobKzgCommitments(fork, block as SignedBeaconBlock<ForkPostDeneb>).length
         : 0;
 
       if (isForkPostFulu(fork) && blobCount > 0) {
@@ -115,7 +117,9 @@ export function getDebugApi({
       }
 
       return {
-        data: indices ? dataColumnSidecars.filter(({index}) => indices.includes(index)) : dataColumnSidecars,
+        data: (indices
+          ? dataColumnSidecars.filter(({index}) => indices.includes(index))
+          : dataColumnSidecars) as DataColumnSidecars,
         meta: {
           executionOptimistic,
           finalized,

package/src/api/impl/node/utils.ts

@@ -1,4 +1,4 @@
-import {Connection, StreamStatus} from "@libp2p/interface";
+import type {Connection, ConnectionStatus} from "@libp2p/interface";
 import {routes} from "@lodestar/api";
 
 /**
@@ -24,7 +24,7 @@ export function formatNodePeer(peerIdStr: string, connections: Connection[]): ro
  * - Otherwise, the first closed connection
  */
 export function getRelevantConnection(connections: Connection[]): Connection | null {
-  const byStatus = new Map<StreamStatus, Connection>();
+  const byStatus = new Map<ConnectionStatus, Connection>();
   for (const conn of connections) {
     if (conn.status === "open") return conn;
     if (!byStatus.has(conn.status)) byStatus.set(conn.status, conn);
@@ -37,7 +37,7 @@ export function getRelevantConnection(connections: Connection[]): Connection | n
  * Map libp2p connection status to the API's peer state notation
  * @param status
  */
-function getPeerState(status: StreamStatus): routes.node.PeerState {
+function getPeerState(status: ConnectionStatus): routes.node.PeerState {
   switch (status) {
     case "open":
       return "connected";