@lodestar/beacon-node 1.41.0-rc.0 → 1.41.0-rc.2

package/src/chain/validation/dataColumnSidecar.ts

@@ -12,6 +12,7 @@ import {
 } from "@lodestar/state-transition";
 import {DataColumnSidecar, Root, Slot, SubnetID, fulu, 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 {kzg} from "../../util/kzg.js";
 import {
@@ -177,6 +178,7 @@ export async function validateGossipDataColumnSidecar(
     });
   }
 
+  // single data column is being verified here
   const kzgProofTimer = metrics?.peerDas.dataColumnSidecarKzgProofsVerificationTime.startTimer();
   // 11) [REJECT] The sidecar's column data is valid as verified by verify_data_column_sidecar_kzg_proofs
   try {
@@ -297,159 +299,177 @@ export async function validateBlockDataColumnSidecars(
   blockSlot: Slot,
   blockRoot: Root,
   blockBlobCount: number,
-  dataColumnSidecars: fulu.DataColumnSidecars
+  dataColumnSidecars: fulu.DataColumnSidecars,
+  metrics?: BeaconMetrics["peerDas"] | null
 ): Promise<void> {
-  if (dataColumnSidecars.length === 0) {
-    return;
-  }
+  metrics?.dataColumnSidecarProcessingRequests.inc(dataColumnSidecars.length);
+  const verificationTimer = metrics?.dataColumnSidecarGossipVerificationTime.startTimer();
+  try {
+    if (dataColumnSidecars.length === 0) {
+      return;
+    }
 
-  if (blockBlobCount === 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"
-    );
-  }
-  // Hash the first sidecar block header and compare the rest via (cheaper) equality
-  const firstSidecarSignedBlockHeader = dataColumnSidecars[0].signedBlockHeader;
-  const firstSidecarBlockHeader = firstSidecarSignedBlockHeader.message;
-  const firstBlockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(firstSidecarBlockHeader);
-  if (!byteArrayEquals(blockRoot, firstBlockRoot)) {
-    throw new DataColumnSidecarValidationError(
-      {
-        code: DataColumnSidecarErrorCode.INCORRECT_BLOCK,
-        slot: blockSlot,
-        columnIndex: 0,
-        expected: toRootHex(blockRoot),
-        actual: toRootHex(firstBlockRoot),
-      },
-      "DataColumnSidecar doesn't match corresponding block"
-    );
-  }
+    if (blockBlobCount === 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"
+      );
+    }
+    // Hash the first sidecar block header and compare the rest via (cheaper) equality
+    const firstSidecarSignedBlockHeader = dataColumnSidecars[0].signedBlockHeader;
+    const firstSidecarBlockHeader = firstSidecarSignedBlockHeader.message;
+    const firstBlockRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(firstSidecarBlockHeader);
+    if (!byteArrayEquals(blockRoot, firstBlockRoot)) {
+      throw new DataColumnSidecarValidationError(
+        {
+          code: DataColumnSidecarErrorCode.INCORRECT_BLOCK,
+          slot: blockSlot,
+          columnIndex: 0,
+          expected: toRootHex(blockRoot),
+          actual: toRootHex(firstBlockRoot),
+        },
+        "DataColumnSidecar doesn't match corresponding block"
+      );
+    }
+
+    if (chain !== null) {
+      const rootHex = toRootHex(blockRoot);
+      const slot = firstSidecarSignedBlockHeader.message.slot;
+      const signature = firstSidecarSignedBlockHeader.signature;
+      if (!chain.seenBlockInputCache.isVerifiedProposerSignature(slot, rootHex, signature)) {
+        const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+          chain.config,
+          firstSidecarSignedBlockHeader
+        );
+
+        if (
+          !(await chain.bls.verifySignatureSets([signatureSet], {
+            verifyOnMainThread: true,
+          }))
+        ) {
+          throw new DataColumnSidecarValidationError({
+            code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
+            blockRoot: rootHex,
+            slot: blockSlot,
+            index: dataColumnSidecars[0].index,
+          });
+        }
+
+        chain.seenBlockInputCache.markVerifiedProposerSignature(slot, rootHex, signature);
+      }
+    }
 
-  if (chain !== null) {
-    const rootHex = toRootHex(blockRoot);
-    const slot = firstSidecarSignedBlockHeader.message.slot;
-    const signature = firstSidecarSignedBlockHeader.signature;
-    if (!chain.seenBlockInputCache.isVerifiedProposerSignature(slot, rootHex, signature)) {
-      const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(chain.config, firstSidecarSignedBlockHeader);
+    const commitments: Uint8Array[] = [];
+    const cellIndices: number[] = [];
+    const cells: Uint8Array[] = [];
+    const proofs: Uint8Array[] = [];
+    for (let i = 0; i < dataColumnSidecars.length; i++) {
+      const columnSidecar = dataColumnSidecars[i];
 
       if (
-        !(await chain.bls.verifySignatureSets([signatureSet], {
-          verifyOnMainThread: true,
-        }))
+        i !== 0 &&
+        !ssz.phase0.SignedBeaconBlockHeader.equals(firstSidecarSignedBlockHeader, columnSidecar.signedBlockHeader)
       ) {
         throw new DataColumnSidecarValidationError({
-          code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID,
-          blockRoot: rootHex,
+          code: DataColumnSidecarErrorCode.INCORRECT_HEADER_ROOT,
           slot: blockSlot,
-          index: dataColumnSidecars[0].index,
+          expected: toRootHex(blockRoot),
+          actual: toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(columnSidecar.signedBlockHeader.message)),
         });
       }
 
-      chain.seenBlockInputCache.markVerifiedProposerSignature(slot, rootHex, signature);
-    }
-  }
+      if (columnSidecar.index >= NUMBER_OF_COLUMNS) {
+        throw new DataColumnSidecarValidationError(
+          {
+            code: DataColumnSidecarErrorCode.INVALID_INDEX,
+            slot: blockSlot,
+            columnIndex: columnSidecar.index,
+          },
+          "DataColumnSidecar has invalid index"
+        );
+      }
 
-  const commitments: Uint8Array[] = [];
-  const cellIndices: number[] = [];
-  const cells: Uint8Array[] = [];
-  const proofs: Uint8Array[] = [];
-  for (let i = 0; i < dataColumnSidecars.length; i++) {
-    const columnSidecar = dataColumnSidecars[i];
+      if (columnSidecar.column.length !== blockBlobCount) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.INCORRECT_CELL_COUNT,
+          slot: blockSlot,
+          columnIndex: columnSidecar.index,
+          expected: blockBlobCount,
+          actual: columnSidecar.column.length,
+        });
+      }
 
-    if (
-      i !== 0 &&
-      !ssz.phase0.SignedBeaconBlockHeader.equals(firstSidecarSignedBlockHeader, columnSidecar.signedBlockHeader)
-    ) {
-      throw new DataColumnSidecarValidationError({
-        code: DataColumnSidecarErrorCode.INCORRECT_HEADER_ROOT,
-        slot: blockSlot,
-        expected: toRootHex(blockRoot),
-        actual: toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(columnSidecar.signedBlockHeader.message)),
-      });
-    }
+      if (columnSidecar.column.length !== columnSidecar.kzgCommitments.length) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT,
+          slot: blockSlot,
+          columnIndex: columnSidecar.index,
+          expected: columnSidecar.column.length,
+          actual: columnSidecar.kzgCommitments.length,
+        });
+      }
 
-    if (columnSidecar.index >= NUMBER_OF_COLUMNS) {
-      throw new DataColumnSidecarValidationError(
-        {
-          code: DataColumnSidecarErrorCode.INVALID_INDEX,
+      if (columnSidecar.column.length !== columnSidecar.kzgProofs.length) {
+        throw new DataColumnSidecarValidationError({
+          code: DataColumnSidecarErrorCode.INCORRECT_KZG_PROOF_COUNT,
           slot: blockSlot,
           columnIndex: columnSidecar.index,
-        },
-        "DataColumnSidecar has invalid index"
-      );
-    }
+          expected: columnSidecar.column.length,
+          actual: columnSidecar.kzgProofs.length,
+        });
+      }
 
-    if (columnSidecar.column.length !== blockBlobCount) {
-      throw new DataColumnSidecarValidationError({
-        code: DataColumnSidecarErrorCode.INCORRECT_CELL_COUNT,
-        slot: blockSlot,
-        columnIndex: columnSidecar.index,
-        expected: blockBlobCount,
-        actual: columnSidecar.column.length,
-      });
-    }
+      const inclusionProofTimer = metrics?.dataColumnSidecarInclusionProofVerificationTime.startTimer();
+      const validInclusionProof = verifyDataColumnSidecarInclusionProof(columnSidecar);
+      inclusionProofTimer?.();
+      if (!validInclusionProof) {
+        throw new DataColumnSidecarValidationError(
+          {
+            code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID,
+            slot: blockSlot,
+            columnIndex: columnSidecar.index,
+          },
+          "DataColumnSidecar has invalid inclusion proof"
+        );
+      }
 
-    if (columnSidecar.column.length !== columnSidecar.kzgCommitments.length) {
-      throw new DataColumnSidecarValidationError({
-        code: DataColumnSidecarErrorCode.INCORRECT_KZG_COMMITMENTS_COUNT,
-        slot: blockSlot,
-        columnIndex: columnSidecar.index,
-        expected: columnSidecar.column.length,
-        actual: columnSidecar.kzgCommitments.length,
-      });
+      commitments.push(...columnSidecar.kzgCommitments);
+      cellIndices.push(...Array.from({length: columnSidecar.column.length}, () => columnSidecar.index));
+      cells.push(...columnSidecar.column);
+      proofs.push(...columnSidecar.kzgProofs);
     }
 
-    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,
-      });
+    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 (!verifyDataColumnSidecarInclusionProof(columnSidecar)) {
+    if (reason !== undefined) {
       throw new DataColumnSidecarValidationError(
         {
-          code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID,
+          code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF_BATCH,
           slot: blockSlot,
-          columnIndex: columnSidecar.index,
+          reason,
         },
-        "DataColumnSidecar has invalid inclusion proof"
+        "DataColumnSidecar has invalid KZG proof batch"
       );
     }
-
-    commitments.push(...columnSidecar.kzgCommitments);
-    cellIndices.push(...Array.from({length: columnSidecar.column.length}, () => columnSidecar.index));
-    cells.push(...columnSidecar.column);
-    proofs.push(...columnSidecar.kzgProofs);
-  }
-
-  let reason: string | undefined;
-  try {
-    const valid = await kzg.asyncVerifyCellKzgProofBatch(commitments, cellIndices, cells, proofs);
-    if (!valid) {
-      reason = "Invalid KZG proof batch";
-    }
-  } catch (e) {
-    reason = (e as Error).message;
-  }
-  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/metrics/metrics/beacon.ts

@@ -333,11 +333,13 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
         help: "Time taken to verify data_column sidecar inclusion proof",
         buckets: [0.002, 0.004, 0.006, 0.008, 0.01, 0.05, 1, 2],
       }),
+      // single verification
       dataColumnSidecarKzgProofsVerificationTime: register.histogram({
         name: "beacon_data_column_sidecar_kzg_proofs_verification_seconds",
-        help: "Time taken to verify data_column sidecar kzg proofs",
+        help: "Time taken to verify single data_column sidecar kzg proofs",
         buckets: [0.01, 0.02, 0.03, 0.04, 0.05, 0.1, 0.2, 0.5, 1],
       }),
+      // batch verification
       kzgVerificationDataColumnBatchTime: register.histogram({
         name: "beacon_kzg_verification_data_column_batch_seconds",
         help: "Runtime of batched data column kzg verification",
@@ -361,10 +363,14 @@ export function createBeaconMetrics(register: RegistryMetricCreator) {
         help: "Duration of engine_getBlobsV2 requests",
         buckets: [0.01, 0.05, 0.1, 0.5, 1, 2.5, 5, 7.5],
       }),
-      targetCustodyGroupCount: register.gauge({
-        name: "beacon_target_custody_group_count",
+      custodyGroupCount: register.gauge({
+        name: "beacon_custody_groups",
         help: "Total number of custody groups within a node",
       }),
+      custodyGroupsBackfilled: register.gauge({
+        name: "beacon_custody_groups_backfilled",
+        help: "Total number of custody groups backfilled by a node",
+      }),
       reconstructedColumns: register.counter({
         name: "beacon_data_availability_reconstructed_columns_total",
         help: "Total count of reconstructed columns",

package/src/metrics/metrics/lodestar.ts

@@ -836,20 +836,23 @@ export function createLodestarMetrics(
         buckets: [0.5, 1, 2, 4, 6, 12],
       }),
     },
-    recoverDataColumnSidecars: {
-      recoverTime: register.histogram({
-        name: "lodestar_recover_data_column_sidecar_recover_time_seconds",
-        help: "Time elapsed to recover data column sidecar",
-        buckets: [0.5, 1.0, 1.5, 2],
+    // recovery in the case of specific blob rows required
+    recoverBlobSidecars: {
+      blobsReconstructed: register.counter({
+        name: "lodestar_blobs_reconstructed_total",
+        help: "Total count of reconstructed blobs",
+      }),
+      reconstructionTime: register.histogram({
+        name: "lodestar_blob_reconstruction_seconds",
+        help: "Time taken to reconstruct blobs",
+        buckets: [0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 2, 5],
       }),
+    },
+    recoverDataColumnSidecars: {
       custodyBeforeReconstruction: register.gauge({
         name: "lodestar_data_columns_in_custody_before_reconstruction",
         help: "Number of data columns in custody before reconstruction",
       }),
-      numberOfColumnsRecovered: register.gauge({
-        name: "lodestar_recover_data_column_sidecar_recovered_columns_total",
-        help: "Total number of columns that were recovered",
-      }),
       reconstructionResult: register.counter<{result: DataColumnReconstructionCode}>({
         name: "lodestar_data_column_sidecars_reconstruction_result",
         help: "Data column sidecars reconstruction result",
@@ -857,6 +860,10 @@ export function createLodestarMetrics(
       }),
     },
     dataColumns: {
+      alreadyAdded: register.counter({
+        name: "lodestar_data_column_sidecar_already_added",
+        help: "Total number of columns that were already added by other sources while waiting",
+      }),
       bySource: register.gauge<{source: BlockInputSource}>({
         name: "lodestar_data_columns_by_source",
         help: "Number of received data columns by source",
@@ -912,11 +919,6 @@ export function createLodestarMetrics(
         help: "Total number of imported blobs by source",
         labelNames: ["blobsSource"],
       }),
-      columnsBySource: register.gauge<{source: BlockInputSource}>({
-        name: "lodestar_import_columns_by_source_total",
-        help: "Total number of imported columns (sampled columns) by source",
-        labelNames: ["source"],
-      }),
       notOverrideFcuReason: register.counter<{reason: NotReorgedReason}>({
         name: "lodestar_import_block_not_override_fcu_reason_total",
         help: "Reason why the fcu call is not suppressed during block import",

package/src/sync/range/range.ts

@@ -206,6 +206,7 @@ export class RangeSync extends (EventEmitter as {new (): RangeSyncEmitter}) {
       logger: this.logger,
       peerIdStr: peer.peerId,
       batchBlocks,
+      peerDasMetrics: this.chain.metrics?.peerDas,
       ...batch.getRequestsForPeer(peer),
     });
     const cached = cacheByRangeResponses({

package/src/sync/utils/downloadByRange.ts

@@ -12,6 +12,7 @@ import {
 import {SeenBlockInput} from "../../chain/seenCache/seenGossipBlockInput.js";
 import {validateBlockBlobSidecars} from "../../chain/validation/blobSidecar.js";
 import {validateBlockDataColumnSidecars} from "../../chain/validation/dataColumnSidecar.js";
+import {BeaconMetrics} from "../../metrics/metrics/beacon.js";
 import {INetwork} from "../../network/index.js";
 import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {PeerIdStr} from "../../util/peerId.js";
@@ -35,6 +36,7 @@ export type DownloadAndCacheByRangeProps = DownloadByRangeRequests & {
   logger: Logger;
   peerIdStr: string;
   batchBlocks?: IBlockInput[];
+  peerDasMetrics?: BeaconMetrics["peerDas"] | null;
 };
 
 export type CacheByRangeResponsesProps = {
@@ -196,6 +198,7 @@ export async function downloadByRange({
   blocksRequest,
   blobsRequest,
   columnsRequest,
+  peerDasMetrics,
 }: DownloadAndCacheByRangeProps): Promise<WarnResult<ValidatedResponses, DownloadByRangeError>> {
   let response: DownloadByRangeResponses;
   try {
@@ -220,6 +223,7 @@ export async function downloadByRange({
     blocksRequest,
     blobsRequest,
     columnsRequest,
+    peerDasMetrics,
     ...response,
   });
 
@@ -290,10 +294,12 @@ export async function validateResponses({
   blocks,
   blobSidecars,
   columnSidecars,
+  peerDasMetrics,
 }: DownloadByRangeRequests &
   DownloadByRangeResponses & {
     config: ChainForkConfig;
     batchBlocks?: IBlockInput[];
+    peerDasMetrics?: BeaconMetrics["peerDas"] | null;
   }): Promise<WarnResult<ValidatedResponses, DownloadByRangeError>> {
   // Blocks are always required for blob/column validation
   // If a blocksRequest is provided, blocks have just been downloaded
@@ -372,7 +378,8 @@ export async function validateResponses({
       config,
       columnsRequest,
       blocksForDataValidation,
-      columnSidecars
+      columnSidecars,
+      peerDasMetrics
     );
     validatedResponses.validatedColumnSidecars = validatedColumnSidecarsResult.result;
     warnings = validatedColumnSidecarsResult.warnings;
@@ -608,7 +615,8 @@ export async function validateColumnsByRangeResponse(
   config: ChainForkConfig,
   request: fulu.DataColumnSidecarsByRangeRequest,
   blocks: ValidatedBlock[],
-  columnSidecars: fulu.DataColumnSidecars
+  columnSidecars: fulu.DataColumnSidecars,
+  peerDasMetrics?: BeaconMetrics["peerDas"] | null
 ): Promise<WarnResult<ValidatedColumnSidecars[], DownloadByRangeError>> {
   const warnings: DownloadByRangeError[] = [];
 
@@ -764,7 +772,8 @@ export async function validateColumnsByRangeResponse(
         slot,
         blockRoot,
         blobCount,
-        columnSidecars
+        columnSidecars,
+        peerDasMetrics
       ).then(() => ({
         blockRoot,
         columnSidecars,

package/src/sync/utils/downloadByRoot.ts

@@ -440,7 +440,7 @@ export async function fetchAndValidateColumns({
     );
   }
 
-  await validateBlockDataColumnSidecars(chain, slot, blockRoot, blobCount, columnSidecars);
+  await validateBlockDataColumnSidecars(chain, slot, blockRoot, blobCount, columnSidecars, chain?.metrics?.peerDas);
 
   return {result: columnSidecars, warnings: warnings.length > 0 ? warnings : null};
 }

package/src/util/dataColumns.ts

@@ -425,7 +425,8 @@ export async function recoverDataColumnSidecars(
     partialSidecars.set(columnSidecar.index, columnSidecar);
   }
 
-  const timer = metrics?.recoverDataColumnSidecars.recoverTime.startTimer();
+  const timer = metrics?.peerDas.dataColumnsReconstructionTime.startTimer();
+
   // if this function throws, we catch at the consumer side
   const fullSidecars = await dataColumnMatrixRecovery(partialSidecars).catch(() => null);
   timer?.();
@@ -435,6 +436,7 @@ export async function recoverDataColumnSidecars(
 
   if (blockInput.getAllColumns().length === NUMBER_OF_COLUMNS) {
     // either gossip or getBlobsV2 resolved availability while we were recovering
+    metrics?.dataColumns.alreadyAdded.inc(fullSidecars.length);
     return DataColumnReconstructionCode.SuccessLate;
   }
 
@@ -458,8 +460,10 @@ export async function recoverDataColumnSidecars(
       sidecarsToPublish.push(columnSidecar);
     }
   }
+  metrics?.peerDas.reconstructedColumns.inc(sidecarsToPublish.length);
+  metrics?.dataColumns.bySource.inc({source: BlockInputSource.recovery}, sidecarsToPublish.length);
   emitter.emit(ChainEvent.publishDataColumns, sidecarsToPublish);
-
+  // TODO: Can we record dataColumns.sentPeersPerSubnet metric somehow
   return DataColumnReconstructionCode.SuccessResolved;
 }
 

package/src/util/execution.ts

@@ -173,16 +173,21 @@ export async function getDataColumnSidecarsFromExecution(
   }
 
   let dataColumnSidecars: fulu.DataColumnSidecars;
-  const cellsAndProofs = await getCellsAndProofs(blobs);
-  if (blockInput.hasBlock()) {
-    dataColumnSidecars = getDataColumnSidecarsFromBlock(
-      config,
-      blockInput.getBlock() as fulu.SignedBeaconBlock,
-      cellsAndProofs
-    );
-  } else {
-    const firstSidecar = blockInput.getAllColumns()[0];
-    dataColumnSidecars = getDataColumnSidecarsFromColumnSidecar(firstSidecar, cellsAndProofs);
+  const compTimer = metrics?.peerDas.dataColumnSidecarComputationTime.startTimer();
+  try {
+    const cellsAndProofs = await getCellsAndProofs(blobs);
+    if (blockInput.hasBlock()) {
+      dataColumnSidecars = getDataColumnSidecarsFromBlock(
+        config,
+        blockInput.getBlock() as fulu.SignedBeaconBlock,
+        cellsAndProofs
+      );
+    } else {
+      const firstSidecar = blockInput.getAllColumns()[0];
+      dataColumnSidecars = getDataColumnSidecarsFromColumnSidecar(firstSidecar, cellsAndProofs);
+    }
+  } finally {
+    compTimer?.();
   }
 
   // Publish columns if and only if subscribed to them
@@ -191,13 +196,15 @@ export async function getDataColumnSidecarsFromExecution(
 
   // for columns that we already seen, it will be ignored through `ignoreDuplicatePublishError` gossip option
   emitter.emit(ChainEvent.publishDataColumns, sampledColumns);
+  // TODO: Can we record dataColumns.sentPeersPerSubnet metric here somehow
 
   // add all sampled columns to the block input, even if we didn't sample them
   const seenTimestampSec = Date.now() / 1000;
+  let alreadyAddedColumnsCount = 0;
   for (const columnSidecar of sampledColumns) {
     if (blockInput.hasColumn(columnSidecar.index)) {
       // columns may have been added while waiting
-      // TODO(fulu): add metrics for this condition
+      alreadyAddedColumnsCount++;
       continue;
     }
 
@@ -217,7 +224,11 @@ export async function getDataColumnSidecarsFromExecution(
       });
     }
   }
+  metrics?.dataColumns.alreadyAdded.inc(alreadyAddedColumnsCount);
 
-  metrics?.dataColumns.bySource.inc({source: BlockInputSource.engine}, previouslyMissingColumns.length);
+  metrics?.dataColumns.bySource.inc(
+    {source: BlockInputSource.engine},
+    previouslyMissingColumns.length - alreadyAddedColumnsCount
+  );
   return DataColumnEngineResult.SuccessResolved;
 }