dapplion · dapplion · Dec 2, 2025
diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs
@@ -152,16 +152,20 @@ impl<E: EthSpec> RpcBlock<E> {
         block_root: Option<Hash256>,
         block: Arc<SignedBeaconBlock<E>>,
         custody_columns: Vec<CustodyDataColumn<E>>,
-    ) -> Result<Self, AvailabilityCheckError> {
+    ) -> Result<Self, String> {
         let block_root = block_root.unwrap_or_else(|| get_block_root(&block));
 
         if block.num_expected_blobs() > 0 && custody_columns.is_empty() {
             // The number of required custody columns is out of scope here.
-            return Err(AvailabilityCheckError::MissingCustodyColumns);
+            return Err("missing expected columns".to_string());
         }
         // Treat empty data column lists as if they are missing.
         let inner = if !custody_columns.is_empty() {
-            RpcBlockInner::BlockAndCustodyColumns(block, VariableList::new(custody_columns)?)
+            RpcBlockInner::BlockAndCustodyColumns(
+                block,
+                VariableList::new(custody_columns)
+                    .map_err(|e| format!("Too many columns {e:?}"))?,
+            )
         } else {
             RpcBlockInner::Block(block)
         };

diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
@@ -2460,7 +2460,8 @@ where
                     .filter(|d| sampling_columns.contains(&d.index))
                     .map(CustodyDataColumn::from_asserted_custody)
                     .collect::<Vec<_>>();
-                RpcBlock::new_with_custody_columns(Some(block_root), block, columns)?
+                RpcBlock::new_with_custody_columns(Some(block_root), block, columns)
+                    .expect("cannot build RpcBlock with columns")
             } else {
                 RpcBlock::new_without_blobs(Some(block_root), block)
             }

diff --git a/beacon_node/lighthouse_network/src/service/api_types.rs b/beacon_node/lighthouse_network/src/service/api_types.rs
@@ -19,9 +19,9 @@ pub struct SingleLookupReqId {
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum SyncRequestId {
     /// Request searching for a block given a hash.
-    SingleBlock { id: SingleLookupReqId },
+    SingleBlock(BlocksByRootRequestId),
     /// Request searching for a set of blobs given a hash.
-    SingleBlob { id: SingleLookupReqId },
+    SingleBlob(BlobsByRootRequestId),
     /// Request searching for a set of data columns given a hash and list of column indices.
     DataColumnsByRoot(DataColumnsByRootRequestId),
     /// Blocks by range request
@@ -32,6 +32,22 @@ pub enum SyncRequestId {
     DataColumnsByRange(DataColumnsByRangeRequestId),
 }
 
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+pub struct BlocksByRootRequestId {
+    /// Id to identify this attempt at a blocks_by_root request for `parent_request_id`
+    pub id: Id,
+    /// The Id of the overall By Root request for block components.
+    pub parent_request_id: ComponentsByRootRequestId,
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+pub struct BlobsByRootRequestId {
+    /// Id to identify this attempt at a blocks_by_root request for `parent_request_id`
+    pub id: Id,
+    /// The Id of the overall By Root request for block components.
+    pub parent_request_id: ComponentsByRootRequestId,
+}
+
 /// Request ID for data_columns_by_root requests. Block lookups do not issue this request directly.
 /// Wrapping this particular req_id, ensures not mixing this request with a custody req_id.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
@@ -86,6 +102,17 @@ pub struct ComponentsByRangeRequestId {
     pub requester: RangeRequestId,
 }
 
+/// Block components by root request for lookup sync. Includes an ID for downstream consumers to
+/// handle retries and tie all their sub requests together.
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+pub struct ComponentsByRootRequestId {
+    /// Each `Id` may request the same data in a later retry. This Id identifies the
+    /// current attempt.
+    pub id: Id,
+    /// What sync component is issuing a components by range request and expecting data back
+    pub requester: RangeRequestId,
+}
+
 /// A batch of data columns by range request for custody sync. Includes an ID for downstream consumers to
 /// handle retries and tie all the range requests for the given epoch together.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
@@ -234,10 +261,13 @@ macro_rules! impl_display {
 // Since each request Id is deeply nested with various types, if rendered with Debug on logs they
 // take too much visual space. This custom Display implementations make the overall Id short while
 // not losing information
+impl_display!(BlocksByRootRequestId, "{}/{}", id, parent_request_id);
 impl_display!(BlocksByRangeRequestId, "{}/{}", id, parent_request_id);
+impl_display!(BlobsByRootRequestId, "{}/{}", id, parent_request_id);
 impl_display!(BlobsByRangeRequestId, "{}/{}", id, parent_request_id);
 impl_display!(DataColumnsByRangeRequestId, "{}/{}", id, parent_request_id);
 impl_display!(ComponentsByRangeRequestId, "{}/{}", id, requester);
+impl_display!(ComponentsByRootRequestId, "{}/{}", id, requester);
 impl_display!(DataColumnsByRootRequestId, "{}/{}", id, requester);
 impl_display!(SingleLookupReqId, "{}/Lookup/{}", req_id, lookup_id);
 impl_display!(CustodyId, "{}", requester);

diff --git a/beacon_node/network/src/sync/block_lookups/common.rs b/beacon_node/network/src/sync/block_lookups/common.rs
@@ -1,217 +0,0 @@
-use crate::sync::block_lookups::single_block_lookup::{
-    LookupRequestError, SingleBlockLookup, SingleLookupRequestState,
-};
-use crate::sync::block_lookups::{
-    BlobRequestState, BlockRequestState, CustodyRequestState, PeerId,
-};
-use crate::sync::manager::BlockProcessType;
-use crate::sync::network_context::{LookupRequestResult, SyncNetworkContext};
-use beacon_chain::BeaconChainTypes;
-use lighthouse_network::service::api_types::Id;
-use parking_lot::RwLock;
-use std::collections::HashSet;
-use std::sync::Arc;
-use types::blob_sidecar::FixedBlobSidecarList;
-use types::{DataColumnSidecarList, SignedBeaconBlock};
-
-use super::SingleLookupId;
-use super::single_block_lookup::{ComponentRequests, DownloadResult};
-
-#[derive(Debug, Copy, Clone)]
-pub enum ResponseType {
-    Block,
-    Blob,
-    CustodyColumn,
-}
-
-/// This trait unifies common single block lookup functionality across blocks and blobs. This
-/// includes making requests, verifying responses, and handling processing results. A
-/// `SingleBlockLookup` includes both a `BlockRequestState` and a `BlobRequestState`, this trait is
-/// implemented for each.
-///
-/// The use of the `ResponseType` associated type gives us a degree of type
-/// safety when handling a block/blob response ensuring we only mutate the correct corresponding
-/// state.
-pub trait RequestState<T: BeaconChainTypes> {
-    /// The type created after validation.
-    type VerifiedResponseType: Clone;
-
-    /// Request the network context to prepare a request of a component of `block_root`. If the
-    /// request is not necessary because the component is already known / processed, return false.
-    /// Return true if it sent a request and we can expect an event back from the network.
-    fn make_request(
-        &self,
-        id: Id,
-        lookup_peers: Arc<RwLock<HashSet<PeerId>>>,
-        expected_blobs: usize,
-        cx: &mut SyncNetworkContext<T>,
-    ) -> Result<LookupRequestResult, LookupRequestError>;
-
-    /* Response handling methods */
-
-    /// Send the response to the beacon processor.
-    fn send_for_processing(
-        id: Id,
-        result: DownloadResult<Self::VerifiedResponseType>,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError>;
-
-    /* Utility methods */
-
-    /// Returns the `ResponseType` associated with this trait implementation. Useful in logging.
-    fn response_type() -> ResponseType;
-
-    /// A getter for the `BlockRequestState` or `BlobRequestState` associated with this trait.
-    fn request_state_mut(request: &mut SingleBlockLookup<T>) -> Result<&mut Self, &'static str>;
-
-    /// A getter for a reference to the `SingleLookupRequestState` associated with this trait.
-    fn get_state(&self) -> &SingleLookupRequestState<Self::VerifiedResponseType>;
-
-    /// A getter for a mutable reference to the SingleLookupRequestState associated with this trait.
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState<Self::VerifiedResponseType>;
-}
-
-impl<T: BeaconChainTypes> RequestState<T> for BlockRequestState<T::EthSpec> {
-    type VerifiedResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
-
-    fn make_request(
-        &self,
-        id: SingleLookupId,
-        lookup_peers: Arc<RwLock<HashSet<PeerId>>>,
-        _: usize,
-        cx: &mut SyncNetworkContext<T>,
-    ) -> Result<LookupRequestResult, LookupRequestError> {
-        cx.block_lookup_request(id, lookup_peers, self.requested_block_root)
-            .map_err(LookupRequestError::SendFailedNetwork)
-    }
-
-    fn send_for_processing(
-        id: SingleLookupId,
-        download_result: DownloadResult<Self::VerifiedResponseType>,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        let DownloadResult {
-            value,
-            block_root,
-            seen_timestamp,
-            ..
-        } = download_result;
-        cx.send_block_for_processing(id, block_root, value, seen_timestamp)
-            .map_err(LookupRequestError::SendFailedProcessor)
-    }
-
-    fn response_type() -> ResponseType {
-        ResponseType::Block
-    }
-    fn request_state_mut(request: &mut SingleBlockLookup<T>) -> Result<&mut Self, &'static str> {
-        Ok(&mut request.block_request_state)
-    }
-    fn get_state(&self) -> &SingleLookupRequestState<Self::VerifiedResponseType> {
-        &self.state
-    }
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState<Self::VerifiedResponseType> {
-        &mut self.state
-    }
-}
-
-impl<T: BeaconChainTypes> RequestState<T> for BlobRequestState<T::EthSpec> {
-    type VerifiedResponseType = FixedBlobSidecarList<T::EthSpec>;
-
-    fn make_request(
-        &self,
-        id: Id,
-        lookup_peers: Arc<RwLock<HashSet<PeerId>>>,
-        expected_blobs: usize,
-        cx: &mut SyncNetworkContext<T>,
-    ) -> Result<LookupRequestResult, LookupRequestError> {
-        cx.blob_lookup_request(id, lookup_peers, self.block_root, expected_blobs)
-            .map_err(LookupRequestError::SendFailedNetwork)
-    }
-
-    fn send_for_processing(
-        id: Id,
-        download_result: DownloadResult<Self::VerifiedResponseType>,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        let DownloadResult {
-            value,
-            block_root,
-            seen_timestamp,
-            ..
-        } = download_result;
-        cx.send_blobs_for_processing(id, block_root, value, seen_timestamp)
-            .map_err(LookupRequestError::SendFailedProcessor)
-    }
-
-    fn response_type() -> ResponseType {
-        ResponseType::Blob
-    }
-    fn request_state_mut(request: &mut SingleBlockLookup<T>) -> Result<&mut Self, &'static str> {
-        match &mut request.component_requests {
-            ComponentRequests::WaitingForBlock => Err("waiting for block"),
-            ComponentRequests::ActiveBlobRequest(request, _) => Ok(request),
-            ComponentRequests::ActiveCustodyRequest { .. } => Err("expecting custody request"),
-            ComponentRequests::NotNeeded { .. } => Err("not needed"),
-        }
-    }
-    fn get_state(&self) -> &SingleLookupRequestState<Self::VerifiedResponseType> {
-        &self.state
-    }
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState<Self::VerifiedResponseType> {
-        &mut self.state
-    }
-}
-
-impl<T: BeaconChainTypes> RequestState<T> for CustodyRequestState<T::EthSpec> {
-    type VerifiedResponseType = DataColumnSidecarList<T::EthSpec>;
-
-    fn make_request(
-        &self,
-        id: Id,
-        lookup_peers: Arc<RwLock<HashSet<PeerId>>>,
-        _: usize,
-        cx: &mut SyncNetworkContext<T>,
-    ) -> Result<LookupRequestResult, LookupRequestError> {
-        cx.custody_lookup_request(id, self.block_root, lookup_peers)
-            .map_err(LookupRequestError::SendFailedNetwork)
-    }
-
-    fn send_for_processing(
-        id: Id,
-        download_result: DownloadResult<Self::VerifiedResponseType>,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        let DownloadResult {
-            value,
-            block_root,
-            seen_timestamp,
-            ..
-        } = download_result;
-        cx.send_custody_columns_for_processing(
-            id,
-            block_root,
-            value,
-            seen_timestamp,
-            BlockProcessType::SingleCustodyColumn(id),
-        )
-        .map_err(LookupRequestError::SendFailedProcessor)
-    }
-
-    fn response_type() -> ResponseType {
-        ResponseType::CustodyColumn
-    }
-    fn request_state_mut(request: &mut SingleBlockLookup<T>) -> Result<&mut Self, &'static str> {
-        match &mut request.component_requests {
-            ComponentRequests::WaitingForBlock => Err("waiting for block"),
-            ComponentRequests::ActiveBlobRequest { .. } => Err("expecting blob request"),
-            ComponentRequests::ActiveCustodyRequest(request) => Ok(request),
-            ComponentRequests::NotNeeded { .. } => Err("not needed"),
-        }
-    }
-    fn get_state(&self) -> &SingleLookupRequestState<Self::VerifiedResponseType> {
-        &self.state
-    }
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState<Self::VerifiedResponseType> {
-        &mut self.state
-    }
-}