From b2246c685c62d25585e506cbcd2b0b1f6fd4070d Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Fri, 14 Jul 2023 16:23:36 -0400
Subject: [PATCH 01/18] Revert "fix merge"

This reverts commit 405e95b0ce15409f06504f45c8d93071523e9539.
---
 .../gossip_methods.rs                         |  2 +-
 .../src/network_beacon_processor/mod.rs       | 26 ++++++++++++++-----
 .../network_beacon_processor/sync_methods.rs  | 22 ++++++++--------
 .../src/network_beacon_processor/tests.rs     | 18 ++++++-------
 beacon_node/network/src/router.rs             | 16 ++++++++----
 beacon_node/network/src/service/tests.rs      |  2 +-
 .../src/sync/block_lookups/delayed_lookup.rs  |  6 ++---
 .../network/src/sync/block_lookups/mod.rs     | 14 ++++------
 beacon_node/network/src/sync/manager.rs       |  2 +-
 .../network/src/sync/range_sync/range.rs      |  2 +-
 10 files changed, 61 insertions(+), 49 deletions(-)

diff --git a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
index 000c4d85dc1..2255b401703 100644
--- a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
@@ -5,8 +5,8 @@ use crate::{
     sync::SyncMessage,
 };
 
-use beacon_chain::blob_verification::AsBlock;
 use beacon_chain::blob_verification::{BlobError, GossipVerifiedBlob};
+use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::store::Error;
 use beacon_chain::{
     attestation_verification::{self, Error as AttnError, VerifiedAttestation},
diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs
index ef4b3daae7a..166417ba93c 100644
--- a/beacon_node/network/src/network_beacon_processor/mod.rs
+++ b/beacon_node/network/src/network_beacon_processor/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     service::NetworkMessage,
     sync::{manager::BlockProcessType, SyncMessage},
 };
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{
     builder::Witness, eth1_chain::CachingEth1Backend, test_utils::BeaconChainHarness, BeaconChain,
 };
@@ -13,7 +13,6 @@ use beacon_processor::{
     MAX_SCHEDULED_WORK_QUEUE_LEN, MAX_WORK_EVENT_QUEUE_LEN,
 };
 use environment::null_logger;
-use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
 use lighthouse_network::{
     rpc::{BlocksByRangeRequest, BlocksByRootRequest, LightClientBootstrapRequest, StatusMessage},
     Client, MessageId, NetworkGlobals, PeerId, PeerRequestId,
@@ -27,6 +26,7 @@ use store::MemoryStore;
 use task_executor::test_utils::TestRuntime;
 use task_executor::TaskExecutor;
 use tokio::sync::mpsc::{self, error::TrySendError};
+use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
 use types::*;
 
 pub use sync_methods::ChainSegmentProcessId;
@@ -229,7 +229,9 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         })
     }
 
-    pub fn send_banana() {}
+    pub fn send_banana(){
+
+    }
 
     /// Create a new `Work` event for some sync committee signature.
     pub fn send_gossip_sync_signature(
@@ -411,7 +413,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     pub fn send_rpc_beacon_block(
         self: &Arc<Self>,
         block_root: Hash256,
-        block: BlockWrapper<T::EthSpec>,
+        block: RpcBlock<T::EthSpec>,
         seen_timestamp: Duration,
         process_type: BlockProcessType,
     ) -> Result<(), Error<T::EthSpec>> {
@@ -452,7 +454,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     pub fn send_chain_segment(
         self: &Arc<Self>,
         process_id: ChainSegmentProcessId,
-        blocks: Vec<BlockWrapper<T::EthSpec>>,
+        blocks: Vec<RpcBlock<T::EthSpec>>,
     ) -> Result<(), Error<T::EthSpec>> {
         let is_backfill = matches!(&process_id, ChainSegmentProcessId::BackSyncBatchId { .. });
         let processor = self.clone();
@@ -561,7 +563,12 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     ) -> Result<(), Error<T::EthSpec>> {
         let processor = self.clone();
         let process_fn = move |send_idle_on_drop| {
-            processor.handle_blobs_by_range_request(send_idle_on_drop, peer_id, request_id, request)
+            processor.handle_blobs_by_range_request(
+                send_idle_on_drop,
+                peer_id,
+                request_id,
+                request,
+            )
         };
 
         self.try_send(BeaconWorkEvent {
@@ -579,7 +586,12 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     ) -> Result<(), Error<T::EthSpec>> {
         let processor = self.clone();
         let process_fn = move |send_idle_on_drop| {
-            processor.handle_blobs_by_root_request(send_idle_on_drop, peer_id, request_id, request)
+            processor.handle_blobs_by_root_request(
+                send_idle_on_drop,
+                peer_id,
+                request_id,
+                request,
+            )
         };
 
         self.try_send(BeaconWorkEvent {
diff --git a/beacon_node/network/src/network_beacon_processor/sync_methods.rs b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
index 8d9146e6888..3a09373c56f 100644
--- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
@@ -6,7 +6,8 @@ use crate::sync::{
     manager::{BlockProcessType, SyncMessage},
     ChainId,
 };
-use beacon_chain::blob_verification::{AsBlock, BlockWrapper, MaybeAvailableBlock};
+use beacon_chain::data_availability_checker::MaybeAvailableBlock;
+use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
 use beacon_chain::data_availability_checker::AvailabilityCheckError;
 use beacon_chain::{
     observed_block_producers::Error as ObserveError, validator_monitor::get_block_delay_ms,
@@ -54,7 +55,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     pub fn generate_rpc_beacon_block_process_fn(
         self: Arc<Self>,
         block_root: Hash256,
-        block: BlockWrapper<T::EthSpec>,
+        block: RpcBlock<T::EthSpec>,
         seen_timestamp: Duration,
         process_type: BlockProcessType,
     ) -> AsyncFn {
@@ -78,7 +79,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     pub fn generate_rpc_beacon_block_fns(
         self: Arc<Self>,
         block_root: Hash256,
-        block: BlockWrapper<T::EthSpec>,
+        block: RpcBlock<T::EthSpec>,
         seen_timestamp: Duration,
         process_type: BlockProcessType,
     ) -> (AsyncFn, BlockingFn) {
@@ -106,7 +107,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     pub async fn process_rpc_block(
         self: Arc<NetworkBeaconProcessor<T>>,
         block_root: Hash256,
-        block: BlockWrapper<T::EthSpec>,
+        block: RpcBlock<T::EthSpec>,
         seen_timestamp: Duration,
         process_type: BlockProcessType,
         reprocess_tx: mpsc::Sender<ReprocessQueueMessage>,
@@ -269,8 +270,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         process_type: BlockProcessType,
     ) -> AsyncFn {
         let process_fn = async move {
-            self.clone()
-                .process_rpc_blobs(block_root, block, seen_timestamp, process_type)
+            self.clone().process_rpc_blobs(block_root, block, seen_timestamp, process_type)
                 .await;
         };
         Box::pin(process_fn)
@@ -306,7 +306,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         });
     }
 
-    pub fn send_delayed_lookup(&self, block_root: Hash256) {
+    pub fn send_delayed_lookup(&self, block_root: Hash256){
         self.send_sync_message(SyncMessage::MissingGossipBlockComponentsDelayed(block_root))
     }
 
@@ -315,7 +315,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     pub async fn process_chain_segment(
         &self,
         sync_type: ChainSegmentProcessId,
-        downloaded_blocks: Vec<BlockWrapper<T::EthSpec>>,
+        downloaded_blocks: Vec<RpcBlock<T::EthSpec>>,
         notify_execution_layer: NotifyExecutionLayer,
     ) {
         let result = match sync_type {
@@ -440,7 +440,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     /// Helper function to process blocks batches which only consumes the chain and blocks to process.
     async fn process_blocks<'a>(
         &self,
-        downloaded_blocks: impl Iterator<Item = &'a BlockWrapper<T::EthSpec>>,
+        downloaded_blocks: impl Iterator<Item = &'a RpcBlock<T::EthSpec>>,
         notify_execution_layer: NotifyExecutionLayer,
     ) -> (usize, Result<(), ChainSegmentFailed>) {
         let blocks: Vec<_> = downloaded_blocks.cloned().collect();
@@ -473,7 +473,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     /// Helper function to process backfill block batches which only consumes the chain and blocks to process.
     fn process_backfill_blocks(
         &self,
-        downloaded_blocks: Vec<BlockWrapper<T::EthSpec>>,
+        downloaded_blocks: Vec<RpcBlock<T::EthSpec>>,
     ) -> (usize, Result<(), ChainSegmentFailed>) {
         let total_blocks = downloaded_blocks.len();
         let available_blocks = match downloaded_blocks
@@ -481,7 +481,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             .map(|block| {
                 self.chain
                     .data_availability_checker
-                    .check_availability(block)
+                    .check_rpc_block_availability(block)
             })
             .collect::<Result<Vec<_>, _>>()
         {
diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs
index 2c37d177aab..39d3575d6e3 100644
--- a/beacon_node/network/src/network_beacon_processor/tests.rs
+++ b/beacon_node/network/src/network_beacon_processor/tests.rs
@@ -336,16 +336,14 @@ impl TestRig {
     }
 
     pub fn enqueue_blobs_by_range_request(&self, count: u64) {
-        self.network_beacon_processor
-            .send_blobs_by_range_request(
-                PeerId::random(),
-                (ConnectionId::new(42), SubstreamId::new(24)),
-                BlobsByRangeRequest {
-                    start_slot: 0,
-                    count,
-                },
-            )
-            .unwrap();
+        self.network_beacon_processor.send_blobs_by_range_request(
+            PeerId::random(),
+            (ConnectionId::new(42), SubstreamId::new(24)),
+            BlobsByRangeRequest {
+                start_slot: 0,
+                count,
+            },
+        ).unwrap();
     }
 
     pub fn enqueue_backfill_batch(&self) {
diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs
index 30a75a91052..5a954d05a40 100644
--- a/beacon_node/network/src/router.rs
+++ b/beacon_node/network/src/router.rs
@@ -209,12 +209,18 @@ impl<T: BeaconChainTypes> Router<T> {
                     .send_blocks_by_roots_request(peer_id, request_id, request),
             ),
             Request::BlobsByRange(request) => self.handle_beacon_processor_send_result(
-                self.network_beacon_processor
-                    .send_blobs_by_range_request(peer_id, request_id, request),
+                self.network_beacon_processor.send_blobs_by_range_request(
+                    peer_id,
+                    request_id,
+                    request,
+                ),
             ),
             Request::BlobsByRoot(request) => self.handle_beacon_processor_send_result(
-                self.network_beacon_processor
-                    .send_blobs_by_roots_request(peer_id, request_id, request),
+                self.network_beacon_processor.send_blobs_by_roots_request(
+                    peer_id,
+                    request_id,
+                    request,
+                ),
             ),
             Request::LightClientBootstrap(request) => self.handle_beacon_processor_send_result(
                 self.network_beacon_processor
@@ -305,7 +311,7 @@ impl<T: BeaconChainTypes> Router<T> {
                         blob_index,
                         signed_blob,
                         timestamp_now(),
-                    ),
+                    )
                 )
             }
             PubsubMessage::VoluntaryExit(exit) => {
diff --git a/beacon_node/network/src/service/tests.rs b/beacon_node/network/src/service/tests.rs
index 544c5dd9c7f..10110aa891b 100644
--- a/beacon_node/network/src/service/tests.rs
+++ b/beacon_node/network/src/service/tests.rs
@@ -3,7 +3,6 @@
 mod tests {
     use crate::persisted_dht::load_dht;
     use crate::{NetworkConfig, NetworkService};
-    use beacon_chain::test_utils::EphemeralHarnessType;
     use beacon_processor::{
         BeaconProcessorSend, MAX_SCHEDULED_WORK_QUEUE_LEN, MAX_WORK_EVENT_QUEUE_LEN,
     };
@@ -13,6 +12,7 @@ mod tests {
     use std::str::FromStr;
     use std::sync::Arc;
     use tokio::{runtime::Runtime, sync::mpsc};
+    use beacon_chain::test_utils::EphemeralHarnessType;
     use types::MinimalEthSpec as E;
 
     type BeaconChainHarness = beacon_chain::test_utils::BeaconChainHarness<EphemeralHarnessType<E>>;
diff --git a/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs b/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs
index 55e9e49db30..c492470b4ae 100644
--- a/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs
@@ -1,12 +1,12 @@
-use crate::network_beacon_processor::NetworkBeaconProcessor;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use slog::crit;
+use slog::{crit, };
 use slot_clock::SlotClock;
 use std::sync::Arc;
 use tokio::sync::mpsc;
 use tokio::time::interval_at;
 use tokio::time::Instant;
-use types::Hash256;
+use types::{ Hash256};
+use crate::network_beacon_processor::NetworkBeaconProcessor;
 
 #[derive(Debug)]
 pub enum DelayedLookupMessage {
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index dfe960832a5..ff095c719ea 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -10,7 +10,7 @@ use super::{
 use crate::metrics;
 use crate::network_beacon_processor::ChainSegmentProcessId;
 use crate::sync::block_lookups::single_block_lookup::LookupId;
-use beacon_chain::blob_verification::{AsBlock, BlockWrapper};
+use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
 use beacon_chain::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
 use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
 use lighthouse_network::rpc::RPCError;
@@ -34,7 +34,7 @@ mod single_block_lookup;
 #[cfg(test)]
 mod tests;
 
-pub type DownloadedBlocks<T> = (Hash256, BlockWrapper<T>);
+pub type DownloadedBlocks<T> = (Hash256, RpcBlock<T>);
 pub type RootBlockTuple<T> = (Hash256, Arc<SignedBeaconBlock<T>>);
 pub type RootBlobsTuple<T> = (Hash256, FixedBlobSidecarList<T>);
 
@@ -381,7 +381,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 if !has_pending_parent_request {
                     let rpc_block = request_ref
                         .get_downloaded_block()
-                        .unwrap_or(BlockWrapper::Block(block));
+                        .unwrap_or(RpcBlock::new_without_blobs(block));
                     // This is the correct block, send it for processing
                     match self.send_block_for_processing(
                         block_root,
@@ -910,11 +910,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     BlockError::ParentUnknown(block) => {
                         let slot = block.slot();
                         let parent_root = block.parent_root();
-                        let (block, blobs) = block.deconstruct();
-                        request_ref.add_unknown_parent_components(UnknownParentComponents::new(
-                            Some(block),
-                            blobs,
-                        ));
+                        request_ref.add_unknown_parent_components(block.into());
                         self.search_parent(slot, root, parent_root, peer_id.to_peer_id(), cx);
                         ShouldRemoveLookup::False
                     }
@@ -1226,7 +1222,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     fn send_block_for_processing(
         &mut self,
         block_root: Hash256,
-        block: BlockWrapper<T::EthSpec>,
+        block: RpcBlock<T::EthSpec>,
         duration: Duration,
         process_type: BlockProcessType,
         cx: &mut SyncNetworkContext<T>,
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index 93b7c9af5bf..8bdf57e2a41 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -127,7 +127,7 @@ pub enum SyncMessage<T: EthSpec> {
     },
 
     /// A block with an unknown parent has been received.
-    UnknownParentBlock(PeerId, BlockWrapper<T>, Hash256),
+    UnknownParentBlock(PeerId, RpcBlock<T>, Hash256),
 
     /// A blob with an unknown parent has been received.
     UnknownParentBlob(PeerId, Arc<BlobSidecar<T>>),
diff --git a/beacon_node/network/src/sync/range_sync/range.rs b/beacon_node/network/src/sync/range_sync/range.rs
index 733cbcc9eae..09a85208d96 100644
--- a/beacon_node/network/src/sync/range_sync/range.rs
+++ b/beacon_node/network/src/sync/range_sync/range.rs
@@ -396,7 +396,7 @@ mod tests {
     use tokio::sync::mpsc;
 
     use beacon_chain::test_utils::{BeaconChainHarness, EphemeralHarnessType};
-    use slot_clock::TestingSlotClock;
+    use slot_clock::{TestingSlotClock, };
     use std::collections::HashSet;
     use std::sync::Arc;
     use store::MemoryStore;

From b19883e63b34a293a24a06a1106d134ed230096c Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Fri, 14 Jul 2023 16:38:17 -0400
Subject: [PATCH 02/18] refactor deneb block processing

---
 beacon_node/beacon_chain/src/beacon_chain.rs  |  17 +-
 .../beacon_chain/src/blob_verification.rs     | 240 +---------
 .../beacon_chain/src/block_verification.rs    | 253 +++-------
 .../src/block_verification_types.rs           | 404 ++++++++++++++++
 .../src/data_availability_checker.rs          | 442 ++++++------------
 .../overflow_lru_cache.rs                     |  28 +-
 beacon_node/beacon_chain/src/lib.rs           |   9 +-
 beacon_node/beacon_chain/src/test_utils.rs    |  37 +-
 .../tests/attestation_production.rs           |  15 +-
 .../beacon_chain/tests/block_verification.rs  |  83 ++--
 beacon_node/beacon_chain/tests/store_tests.rs |   8 +-
 beacon_node/http_api/src/publish_blocks.rs    |   2 +-
 .../network/src/sync/backfill_sync/mod.rs     |   6 +-
 .../src/sync/block_lookups/parent_lookup.rs   |   8 +-
 .../sync/block_lookups/single_block_lookup.rs |  25 +-
 .../network/src/sync/block_lookups/tests.rs   |   2 +-
 .../src/sync/block_sidecar_coupling.rs        |  44 +-
 beacon_node/network/src/sync/manager.rs       |  12 +-
 .../network/src/sync/network_context.rs       |   4 +-
 .../network/src/sync/range_sync/batch.rs      |  16 +-
 .../network/src/sync/range_sync/chain.rs      |   4 +-
 .../network/src/sync/range_sync/range.rs      |   5 +-
 consensus/fork_choice/tests/tests.rs          |   3 +-
 .../state_processing/src/consensus_context.rs |  12 -
 consensus/types/src/lib.rs                    |   7 +-
 consensus/types/src/signed_beacon_block.rs    |  21 +
 26 files changed, 804 insertions(+), 903 deletions(-)
 create mode 100644 beacon_node/beacon_chain/src/block_verification_types.rs

diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index 84039e42268..3713f8771ae 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -8,13 +8,16 @@ use crate::beacon_block_streamer::{BeaconBlockStreamer, CheckEarlyAttesterCache}
 use crate::beacon_proposer_cache::compute_proposer_duties_from_head;
 use crate::beacon_proposer_cache::BeaconProposerCache;
 use crate::blob_cache::BlobCache;
-use crate::blob_verification::{self, AsBlock, BlobError, BlockWrapper, GossipVerifiedBlob};
+use crate::blob_verification::{self, BlobError, GossipVerifiedBlob};
 use crate::block_times_cache::BlockTimesCache;
 use crate::block_verification::POS_PANDA_BANNER;
 use crate::block_verification::{
     check_block_is_finalized_checkpoint_or_descendant, check_block_relevancy, get_block_root,
-    signature_verify_chain_segment, AvailableExecutedBlock, BlockError, BlockImportData,
-    ExecutedBlock, ExecutionPendingBlock, GossipVerifiedBlock, IntoExecutionPendingBlock,
+    signature_verify_chain_segment, BlockError, ExecutionPendingBlock, GossipVerifiedBlock,
+    IntoExecutionPendingBlock,
+};
+use crate::block_verification_types::{
+    AsBlock, AvailableExecutedBlock, BlockImportData, ExecutedBlock, RpcBlock,
 };
 pub use crate::canonical_head::{CanonicalHead, CanonicalHeadRwLock};
 use crate::chain_config::ChainConfig;
@@ -122,7 +125,7 @@ use types::*;
 pub type ForkChoiceError = fork_choice::Error<crate::ForkChoiceStoreError>;
 
 /// Alias to appease clippy.
-type HashBlockTuple<E> = (Hash256, BlockWrapper<E>);
+type HashBlockTuple<E> = (Hash256, RpcBlock<E>);
 
 /// The time-out before failure during an operation to take a read/write RwLock on the block
 /// processing cache.
@@ -2490,7 +2493,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     /// This method is potentially long-running and should not run on the core executor.
     pub fn filter_chain_segment(
         self: &Arc<Self>,
-        chain_segment: Vec<BlockWrapper<T::EthSpec>>,
+        chain_segment: Vec<RpcBlock<T::EthSpec>>,
     ) -> Result<Vec<HashBlockTuple<T::EthSpec>>, ChainSegmentResult<T::EthSpec>> {
         // This function will never import any blocks.
         let imported_blocks = 0;
@@ -2596,7 +2599,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     /// `Self::process_block`.
     pub async fn process_chain_segment(
         self: &Arc<Self>,
-        chain_segment: Vec<BlockWrapper<T::EthSpec>>,
+        chain_segment: Vec<RpcBlock<T::EthSpec>>,
         notify_execution_layer: NotifyExecutionLayer,
     ) -> ChainSegmentResult<T::EthSpec> {
         let mut imported_blocks = 0;
@@ -2773,7 +2776,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     ///
     /// - `SignedBeaconBlock`
     /// - `GossipVerifiedBlock`
-    /// - `BlockWrapper`
+    /// - `RpcBlock`
     ///
     /// ## Errors
     ///
diff --git a/beacon_node/beacon_chain/src/blob_verification.rs b/beacon_node/beacon_chain/src/blob_verification.rs
index da3ae2c93b0..78e48f0ed65 100644
--- a/beacon_node/beacon_chain/src/blob_verification.rs
+++ b/beacon_node/beacon_chain/src/blob_verification.rs
@@ -7,22 +7,18 @@ use crate::beacon_chain::{
     BeaconChain, BeaconChainTypes, BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT,
     MAXIMUM_GOSSIP_CLOCK_DISPARITY, VALIDATOR_PUBKEY_CACHE_LOCK_TIMEOUT,
 };
-use crate::data_availability_checker::{
-    AvailabilityCheckError, AvailabilityPendingBlock, AvailableBlock,
-};
+use crate::data_availability_checker::AvailabilityCheckError;
 use crate::kzg_utils::{validate_blob, validate_blobs};
 use crate::BeaconChainError;
-use eth2::types::BlockContentsTuple;
 use kzg::Kzg;
 use slog::{debug, warn};
 use ssz_derive::{Decode, Encode};
-use ssz_types::{FixedVector, VariableList};
+use ssz_types::VariableList;
 use std::borrow::Cow;
-use types::blob_sidecar::{BlobIdentifier, FixedBlobSidecarList};
+use types::blob_sidecar::BlobIdentifier;
 use types::{
-    BeaconBlockRef, BeaconState, BeaconStateError, BlobSidecar, BlobSidecarList, ChainSpec,
-    CloneConfig, Epoch, EthSpec, FullPayload, Hash256, KzgCommitment, RelativeEpoch,
-    SignedBeaconBlock, SignedBeaconBlockHeader, SignedBlobSidecar, Slot,
+    BeaconState, BeaconStateError, BlobSidecar, BlobSidecarList, ChainSpec, CloneConfig, EthSpec,
+    Hash256, KzgCommitment, RelativeEpoch, SignedBlobSidecar, Slot,
 };
 
 #[derive(Debug)]
@@ -519,13 +515,12 @@ pub fn verify_kzg_for_blob<T: EthSpec>(
 /// Note: This function should be preferred over calling `verify_kzg_for_blob`
 /// in a loop since this function kzg verifies a list of blobs more efficiently.
 pub fn verify_kzg_for_blob_list<T: EthSpec>(
-    blob_list: Vec<Arc<BlobSidecar<T>>>,
+    blob_list: &BlobSidecarList<T>,
     kzg: &Kzg<T::Kzg>,
-) -> Result<KzgVerifiedBlobList<T>, AvailabilityCheckError> {
+) -> Result<(), AvailabilityCheckError> {
     let _timer = crate::metrics::start_timer(&crate::metrics::KZG_VERIFICATION_BATCH_TIMES);
     let (blobs, (commitments, proofs)): (Vec<_>, (Vec<_>, Vec<_>)) = blob_list
-        .clone()
-        .into_iter()
+        .iter()
         .map(|blob| (blob.blob.clone(), (blob.kzg_commitment, blob.kzg_proof)))
         .unzip();
     if validate_blobs::<T>(
@@ -536,225 +531,8 @@ pub fn verify_kzg_for_blob_list<T: EthSpec>(
     )
     .map_err(AvailabilityCheckError::Kzg)?
     {
-        Ok(blob_list
-            .into_iter()
-            .map(|blob| KzgVerifiedBlob { blob })
-            .collect())
+        Ok(())
     } else {
         Err(AvailabilityCheckError::KzgVerificationFailed)
     }
 }
-
-pub type KzgVerifiedBlobList<T> = Vec<KzgVerifiedBlob<T>>;
-
-#[derive(Debug, Clone)]
-pub enum MaybeAvailableBlock<E: EthSpec> {
-    /// This variant is fully available.
-    /// i.e. for pre-deneb blocks, it contains a (`SignedBeaconBlock`, `Blobs::None`) and for
-    /// post-4844 blocks, it contains a `SignedBeaconBlock` and a Blobs variant other than `Blobs::None`.
-    Available(AvailableBlock<E>),
-    /// This variant is not fully available and requires blobs to become fully available.
-    AvailabilityPending(AvailabilityPendingBlock<E>),
-}
-
-/// Trait for common block operations.
-pub trait AsBlock<E: EthSpec> {
-    fn slot(&self) -> Slot;
-    fn epoch(&self) -> Epoch;
-    fn parent_root(&self) -> Hash256;
-    fn state_root(&self) -> Hash256;
-    fn signed_block_header(&self) -> SignedBeaconBlockHeader;
-    fn message(&self) -> BeaconBlockRef<E>;
-    fn as_block(&self) -> &SignedBeaconBlock<E>;
-    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>>;
-    fn canonical_root(&self) -> Hash256;
-    fn into_block_wrapper(self) -> BlockWrapper<E>;
-}
-
-impl<E: EthSpec> AsBlock<E> for MaybeAvailableBlock<E> {
-    fn slot(&self) -> Slot {
-        self.as_block().slot()
-    }
-    fn epoch(&self) -> Epoch {
-        self.as_block().epoch()
-    }
-    fn parent_root(&self) -> Hash256 {
-        self.as_block().parent_root()
-    }
-    fn state_root(&self) -> Hash256 {
-        self.as_block().state_root()
-    }
-    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
-        self.as_block().signed_block_header()
-    }
-    fn message(&self) -> BeaconBlockRef<E> {
-        self.as_block().message()
-    }
-    fn as_block(&self) -> &SignedBeaconBlock<E> {
-        match &self {
-            MaybeAvailableBlock::Available(block) => block.as_block(),
-            MaybeAvailableBlock::AvailabilityPending(block) => block.as_block(),
-        }
-    }
-    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
-        match &self {
-            MaybeAvailableBlock::Available(block) => block.block_cloned(),
-            MaybeAvailableBlock::AvailabilityPending(block) => block.block_cloned(),
-        }
-    }
-    fn canonical_root(&self) -> Hash256 {
-        self.as_block().canonical_root()
-    }
-
-    fn into_block_wrapper(self) -> BlockWrapper<E> {
-        match self {
-            MaybeAvailableBlock::Available(available_block) => available_block.into_block_wrapper(),
-            MaybeAvailableBlock::AvailabilityPending(pending_block) => {
-                BlockWrapper::Block(pending_block.to_block())
-            }
-        }
-    }
-}
-
-impl<E: EthSpec> AsBlock<E> for &MaybeAvailableBlock<E> {
-    fn slot(&self) -> Slot {
-        self.as_block().slot()
-    }
-    fn epoch(&self) -> Epoch {
-        self.as_block().epoch()
-    }
-    fn parent_root(&self) -> Hash256 {
-        self.as_block().parent_root()
-    }
-    fn state_root(&self) -> Hash256 {
-        self.as_block().state_root()
-    }
-    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
-        self.as_block().signed_block_header()
-    }
-    fn message(&self) -> BeaconBlockRef<E> {
-        self.as_block().message()
-    }
-    fn as_block(&self) -> &SignedBeaconBlock<E> {
-        match &self {
-            MaybeAvailableBlock::Available(block) => block.as_block(),
-            MaybeAvailableBlock::AvailabilityPending(block) => block.as_block(),
-        }
-    }
-    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
-        match &self {
-            MaybeAvailableBlock::Available(block) => block.block_cloned(),
-            MaybeAvailableBlock::AvailabilityPending(block) => block.block_cloned(),
-        }
-    }
-    fn canonical_root(&self) -> Hash256 {
-        self.as_block().canonical_root()
-    }
-
-    fn into_block_wrapper(self) -> BlockWrapper<E> {
-        self.clone().into_block_wrapper()
-    }
-}
-
-#[derive(Debug, Clone, Derivative)]
-#[derivative(Hash(bound = "E: EthSpec"))]
-pub enum BlockWrapper<E: EthSpec> {
-    Block(Arc<SignedBeaconBlock<E>>),
-    BlockAndBlobs(Arc<SignedBeaconBlock<E>>, FixedBlobSidecarList<E>),
-}
-
-impl<E: EthSpec> BlockWrapper<E> {
-    pub fn new(block: Arc<SignedBeaconBlock<E>>, blobs: Option<BlobSidecarList<E>>) -> Self {
-        match blobs {
-            Some(blobs) => {
-                let blobs = FixedVector::from(blobs.into_iter().map(Some).collect::<Vec<_>>());
-                BlockWrapper::BlockAndBlobs(block, blobs)
-            }
-            None => BlockWrapper::Block(block),
-        }
-    }
-    pub fn deconstruct(self) -> (Arc<SignedBeaconBlock<E>>, Option<FixedBlobSidecarList<E>>) {
-        match self {
-            BlockWrapper::Block(block) => (block, None),
-            BlockWrapper::BlockAndBlobs(block, blobs) => (block, Some(blobs)),
-        }
-    }
-}
-
-impl<E: EthSpec> AsBlock<E> for BlockWrapper<E> {
-    fn slot(&self) -> Slot {
-        self.as_block().slot()
-    }
-    fn epoch(&self) -> Epoch {
-        self.as_block().epoch()
-    }
-    fn parent_root(&self) -> Hash256 {
-        self.as_block().parent_root()
-    }
-    fn state_root(&self) -> Hash256 {
-        self.as_block().state_root()
-    }
-    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
-        self.as_block().signed_block_header()
-    }
-    fn message(&self) -> BeaconBlockRef<E> {
-        self.as_block().message()
-    }
-    fn as_block(&self) -> &SignedBeaconBlock<E> {
-        match &self {
-            BlockWrapper::Block(block) => block,
-            BlockWrapper::BlockAndBlobs(block, _) => block,
-        }
-    }
-    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
-        match &self {
-            BlockWrapper::Block(block) => block.clone(),
-            BlockWrapper::BlockAndBlobs(block, _) => block.clone(),
-        }
-    }
-    fn canonical_root(&self) -> Hash256 {
-        self.as_block().canonical_root()
-    }
-
-    fn into_block_wrapper(self) -> BlockWrapper<E> {
-        self
-    }
-}
-
-impl<E: EthSpec> BlockWrapper<E> {
-    pub fn n_blobs(&self) -> usize {
-        match self {
-            BlockWrapper::Block(_) => 0,
-            BlockWrapper::BlockAndBlobs(_, blobs) => blobs.len(),
-        }
-    }
-}
-
-impl<E: EthSpec> From<Arc<SignedBeaconBlock<E>>> for BlockWrapper<E> {
-    fn from(value: Arc<SignedBeaconBlock<E>>) -> Self {
-        Self::Block(value)
-    }
-}
-
-impl<E: EthSpec> From<SignedBeaconBlock<E>> for BlockWrapper<E> {
-    fn from(value: SignedBeaconBlock<E>) -> Self {
-        Self::Block(Arc::new(value))
-    }
-}
-
-impl<E: EthSpec> From<BlockContentsTuple<E, FullPayload<E>>> for BlockWrapper<E> {
-    fn from(value: BlockContentsTuple<E, FullPayload<E>>) -> Self {
-        match value.1 {
-            Some(variable_list) => {
-                let mut blobs = Vec::with_capacity(E::max_blobs_per_block());
-                for blob in variable_list {
-                    if blob.message.index < E::max_blobs_per_block() as u64 {
-                        blobs.insert(blob.message.index as usize, Some(blob.message));
-                    }
-                }
-                Self::BlockAndBlobs(Arc::new(value.0), FixedVector::from(blobs))
-            }
-            None => Self::Block(Arc::new(value.0)),
-        }
-    }
-}
diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
index 796712ed203..dfe388417f9 100644
--- a/beacon_node/beacon_chain/src/block_verification.rs
+++ b/beacon_node/beacon_chain/src/block_verification.rs
@@ -48,13 +48,11 @@
 // returned alongside.
 #![allow(clippy::result_large_err)]
 
-use crate::blob_verification::{
-    AsBlock, BlobError, BlockWrapper, GossipVerifiedBlob, GossipVerifiedBlobList,
-    MaybeAvailableBlock,
-};
-use crate::data_availability_checker::{
-    AvailabilityCheckError, AvailabilityPendingBlock, AvailableBlock,
+use crate::blob_verification::{BlobError, GossipVerifiedBlob};
+use crate::block_verification_types::{
+    AsBlock, BlockImportData, GossipVerifiedBlockContents, RpcBlock,
 };
+use crate::data_availability_checker::{AvailabilityCheckError, MaybeAvailableBlock};
 use crate::eth1_finalization_cache::Eth1FinalizationData;
 use crate::execution_payload::{
     is_optimistic_candidate_block, validate_execution_payload_for_gossip, validate_merge_block,
@@ -99,13 +97,11 @@ use std::time::Duration;
 use store::{Error as DBError, HotStateSummary, KeyValueStore, SignedBlobSidecarList, StoreOp};
 use task_executor::JoinHandle;
 use tree_hash::TreeHash;
-use types::blob_sidecar::BlobIdentifier;
 use types::ExecPayload;
-use types::{ssz_tagged_beacon_state, ssz_tagged_signed_beacon_block};
 use types::{
-    BeaconBlockRef, BeaconState, BeaconStateError, BlindedPayload, ChainSpec, CloneConfig, Epoch,
-    EthSpec, ExecutionBlockHash, Hash256, InconsistentFork, PublicKey, PublicKeyBytes,
-    RelativeEpoch, SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
+    BeaconBlockRef, BeaconState, BeaconStateError, ChainSpec, CloneConfig, Epoch, EthSpec,
+    ExecutionBlockHash, Hash256, InconsistentFork, PublicKey, PublicKeyBytes, RelativeEpoch,
+    SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
 };
 
 pub const POS_PANDA_BANNER: &str = r#"
@@ -153,7 +149,7 @@ pub enum BlockError<T: EthSpec> {
     ///
     /// It's unclear if this block is valid, but it cannot be processed without already knowing
     /// its parent.
-    ParentUnknown(BlockWrapper<T>),
+    ParentUnknown(RpcBlock<T>),
     /// The block slot is greater than the present slot.
     ///
     /// ## Peer scoring
@@ -558,7 +554,7 @@ fn process_block_slash_info<T: BeaconChainTypes>(
 /// The given `chain_segment` must contain only blocks from the same epoch, otherwise an error
 /// will be returned.
 pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
-    mut chain_segment: Vec<(Hash256, BlockWrapper<T::EthSpec>)>,
+    mut chain_segment: Vec<(Hash256, RpcBlock<T::EthSpec>)>,
     chain: &BeaconChain<T>,
 ) -> Result<Vec<SignatureVerifiedBlock<T>>, BlockError<T::EthSpec>> {
     if chain_segment.is_empty() {
@@ -595,7 +591,7 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
 
         let maybe_available_block = chain
             .data_availability_checker
-            .check_availability(block.clone())?;
+            .check_rpc_block_availability(block.clone())?;
 
         // Save the block and its consensus context. The context will have had its proposer index
         // and attesting indices filled in, which can be used to accelerate later block processing.
@@ -625,19 +621,12 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
 #[derive(Derivative)]
 #[derivative(Debug(bound = "T: BeaconChainTypes"))]
 pub struct GossipVerifiedBlock<T: BeaconChainTypes> {
-    pub block: MaybeAvailableBlock<T::EthSpec>,
+    pub block: Arc<SignedBeaconBlock<T::EthSpec>>,
     pub block_root: Hash256,
     parent: Option<PreProcessingSnapshot<T::EthSpec>>,
     consensus_context: ConsensusContext<T::EthSpec>,
 }
 
-impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
-    /// Useful for publishing after gossip verification.
-    pub fn into_block_wrapper(self) -> BlockWrapper<T::EthSpec> {
-        self.block.into_block_wrapper()
-    }
-}
-
 /// A wrapper around a `SignedBeaconBlock` that indicates that all signatures (except the deposit
 /// signatures) have been verified.
 pub struct SignatureVerifiedBlock<T: BeaconChainTypes> {
@@ -669,147 +658,6 @@ pub struct ExecutionPendingBlock<T: BeaconChainTypes> {
     pub payload_verification_handle: PayloadVerificationHandle<T::EthSpec>,
 }
 
-pub enum ExecutedBlock<E: EthSpec> {
-    Available(AvailableExecutedBlock<E>),
-    AvailabilityPending(AvailabilityPendingExecutedBlock<E>),
-}
-
-impl<E: EthSpec> ExecutedBlock<E> {
-    pub fn as_block(&self) -> &SignedBeaconBlock<E> {
-        match self {
-            Self::Available(available) => available.block.block(),
-            Self::AvailabilityPending(pending) => pending.block.as_block(),
-        }
-    }
-}
-
-impl<E: EthSpec> std::fmt::Debug for ExecutedBlock<E> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self.as_block())
-    }
-}
-
-impl<E: EthSpec> ExecutedBlock<E> {
-    pub fn new(
-        block: MaybeAvailableBlock<E>,
-        import_data: BlockImportData<E>,
-        payload_verification_outcome: PayloadVerificationOutcome,
-    ) -> Self {
-        match block {
-            MaybeAvailableBlock::Available(available_block) => {
-                Self::Available(AvailableExecutedBlock::new(
-                    available_block,
-                    import_data,
-                    payload_verification_outcome,
-                ))
-            }
-            MaybeAvailableBlock::AvailabilityPending(pending_block) => {
-                Self::AvailabilityPending(AvailabilityPendingExecutedBlock::new(
-                    pending_block,
-                    import_data,
-                    payload_verification_outcome,
-                ))
-            }
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub struct AvailableExecutedBlock<E: EthSpec> {
-    pub block: AvailableBlock<E>,
-    pub import_data: BlockImportData<E>,
-    pub payload_verification_outcome: PayloadVerificationOutcome,
-}
-
-impl<E: EthSpec> AvailableExecutedBlock<E> {
-    pub fn new(
-        block: AvailableBlock<E>,
-        import_data: BlockImportData<E>,
-        payload_verification_outcome: PayloadVerificationOutcome,
-    ) -> Self {
-        Self {
-            block,
-            import_data,
-            payload_verification_outcome,
-        }
-    }
-
-    pub fn get_all_blob_ids(&self) -> Vec<BlobIdentifier> {
-        let num_blobs_expected = self
-            .block
-            .message()
-            .body()
-            .blob_kzg_commitments()
-            .map_or(0, |commitments| commitments.len());
-        let mut blob_ids = Vec::with_capacity(num_blobs_expected);
-        for i in 0..num_blobs_expected {
-            blob_ids.push(BlobIdentifier {
-                block_root: self.import_data.block_root,
-                index: i as u64,
-            });
-        }
-        blob_ids
-    }
-}
-
-#[derive(Encode, Decode, Clone)]
-pub struct AvailabilityPendingExecutedBlock<E: EthSpec> {
-    pub block: AvailabilityPendingBlock<E>,
-    pub import_data: BlockImportData<E>,
-    pub payload_verification_outcome: PayloadVerificationOutcome,
-}
-
-impl<E: EthSpec> AvailabilityPendingExecutedBlock<E> {
-    pub fn new(
-        block: AvailabilityPendingBlock<E>,
-        import_data: BlockImportData<E>,
-        payload_verification_outcome: PayloadVerificationOutcome,
-    ) -> Self {
-        Self {
-            block,
-            import_data,
-            payload_verification_outcome,
-        }
-    }
-
-    pub fn num_blobs_expected(&self) -> usize {
-        self.block
-            .kzg_commitments()
-            .map_or(0, |commitments| commitments.len())
-    }
-
-    pub fn get_all_blob_ids(&self) -> Vec<BlobIdentifier> {
-        let block_root = self.import_data.block_root;
-        self.block
-            .get_filtered_blob_ids(Some(block_root), |_, _| true)
-    }
-
-    pub fn get_filtered_blob_ids(
-        &self,
-        filter: impl Fn(usize, Hash256) -> bool,
-    ) -> Vec<BlobIdentifier> {
-        self.block
-            .get_filtered_blob_ids(Some(self.import_data.block_root), filter)
-    }
-}
-
-#[derive(Debug, PartialEq, Encode, Decode, Clone)]
-// TODO (mark): investigate using an Arc<state> / Arc<parent_block>
-//              here to make this cheaper to clone
-pub struct BlockImportData<E: EthSpec> {
-    pub block_root: Hash256,
-    #[ssz(with = "ssz_tagged_beacon_state")]
-    pub state: BeaconState<E>,
-    #[ssz(with = "ssz_tagged_signed_beacon_block")]
-    pub parent_block: SignedBeaconBlock<E, BlindedPayload<E>>,
-    pub parent_eth1_finalization_data: Eth1FinalizationData,
-    pub confirmed_state_roots: Vec<Hash256>,
-    pub consensus_context: ConsensusContext<E>,
-}
-
-pub type GossipVerifiedBlockContents<T> =
-    (GossipVerifiedBlock<T>, Option<GossipVerifiedBlobList<T>>);
-
 pub trait IntoGossipVerifiedBlockContents<T: BeaconChainTypes>: Sized {
     fn into_gossip_verified_block(
         self,
@@ -911,27 +759,23 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
         block: Arc<SignedBeaconBlock<T::EthSpec>>,
         chain: &BeaconChain<T>,
     ) -> Result<Self, BlockError<T::EthSpec>> {
-        let maybe_available = chain
-            .data_availability_checker
-            .check_availability(block.into())?;
         // If the block is valid for gossip we don't supply it to the slasher here because
         // we assume it will be transformed into a fully verified block. We *do* need to supply
         // it to the slasher if an error occurs, because that's the end of this block's journey,
         // and it could be a repeat proposal (a likely cause for slashing!).
-        let header = maybe_available.signed_block_header();
-        Self::new_without_slasher_checks(maybe_available, chain).map_err(|e| {
+        let header = block.signed_block_header();
+        Self::new_without_slasher_checks(block, chain).map_err(|e| {
             process_block_slash_info(chain, BlockSlashInfo::from_early_error(header, e))
         })
     }
 
     /// As for new, but doesn't pass the block to the slasher.
     fn new_without_slasher_checks(
-        block: MaybeAvailableBlock<T::EthSpec>,
+        block: Arc<SignedBeaconBlock<T::EthSpec>>,
         chain: &BeaconChain<T>,
     ) -> Result<Self, BlockError<T::EthSpec>> {
         // Ensure the block is the correct structure for the fork at `block.slot()`.
         block
-            .as_block()
             .fork_name(&chain.spec)
             .map_err(BlockError::InconsistentFork)?;
 
@@ -947,7 +791,7 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
             });
         }
 
-        let block_root = get_block_root(block.as_block());
+        let block_root = get_block_root(&block);
 
         // Disallow blocks that conflict with the anchor (weak subjectivity checkpoint), if any.
         check_block_against_anchor_slot(block.message(), chain)?;
@@ -1067,7 +911,7 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
             let pubkey = pubkey_cache
                 .get(block.message().proposer_index() as usize)
                 .ok_or_else(|| BlockError::UnknownValidator(block.message().proposer_index()))?;
-            block.as_block().verify_signature(
+            block.verify_signature(
                 Some(block_root),
                 pubkey,
                 &fork,
@@ -1111,8 +955,7 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
         // Having checked the proposer index and the block root we can cache them.
         let consensus_context = ConsensusContext::new(block.slot())
             .set_current_block_root(block_root)
-            .set_proposer_index(block.as_block().message().proposer_index())
-            .set_kzg_commitments_consistent(true);
+            .set_proposer_index(block.as_block().message().proposer_index());
 
         Ok(Self {
             block,
@@ -1155,11 +998,10 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
     ///
     /// Returns an error if the block is invalid, or if the block was unable to be verified.
     pub fn new(
-        block: BlockWrapper<T::EthSpec>,
+        block: MaybeAvailableBlock<T::EthSpec>,
         block_root: Hash256,
         chain: &BeaconChain<T>,
     ) -> Result<Self, BlockError<T::EthSpec>> {
-        let block = chain.data_availability_checker.check_availability(block)?;
         // Ensure the block is the correct structure for the fork at `block.slot()`.
         block
             .as_block()
@@ -1182,10 +1024,8 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
 
         let mut signature_verifier = get_signature_verifier(&state, &pubkey_cache, &chain.spec);
 
-        let mut consensus_context = ConsensusContext::new(block.slot())
-            .set_current_block_root(block_root)
-            // An `AvailabileBlock is passed in here, so we know this check has been run.`
-            .set_kzg_commitments_consistent(true);
+        let mut consensus_context =
+            ConsensusContext::new(block.slot()).set_current_block_root(block_root);
 
         signature_verifier.include_all_signatures(block.as_block(), &mut consensus_context)?;
 
@@ -1203,7 +1043,7 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
 
     /// As for `new` above but producing `BlockSlashInfo`.
     pub fn check_slashable(
-        block: BlockWrapper<T::EthSpec>,
+        block: MaybeAvailableBlock<T::EthSpec>,
         block_root: Hash256,
         chain: &BeaconChain<T>,
     ) -> Result<Self, BlockSlashInfo<BlockError<T::EthSpec>>> {
@@ -1238,11 +1078,11 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
         // signature.
         let mut consensus_context = from.consensus_context;
         signature_verifier
-            .include_all_signatures_except_proposal(block.as_block(), &mut consensus_context)?;
+            .include_all_signatures_except_proposal(block.as_ref(), &mut consensus_context)?;
 
         if signature_verifier.verify().is_ok() {
             Ok(Self {
-                block,
+                block: MaybeAvailableBlock::AvailabilityPending(block),
                 block_root: from.block_root,
                 parent: Some(parent),
                 consensus_context,
@@ -1299,6 +1139,7 @@ impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for SignatureVerifiedBloc
     }
 }
 
+//TODO(sean) can this be deleted
 impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for Arc<SignedBeaconBlock<T::EthSpec>> {
     /// Verifies the `SignedBeaconBlock` by first transforming it into a `SignatureVerifiedBlock`
     /// and then using that implementation of `IntoExecutionPendingBlock` to complete verification.
@@ -1311,9 +1152,21 @@ impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for Arc<SignedBeaconBlock
         // Perform an early check to prevent wasting time on irrelevant blocks.
         let block_root = check_block_relevancy(&self, block_root, chain)
             .map_err(|e| BlockSlashInfo::SignatureNotChecked(self.signed_block_header(), e))?;
-
-        SignatureVerifiedBlock::check_slashable(self.into(), block_root, chain)?
-            .into_execution_pending_block_slashable(block_root, chain, notify_execution_layer)
+        let maybe_available = chain
+            .data_availability_checker
+            .check_rpc_block_availability(RpcBlock::new_without_blobs(self.clone()))
+            .map_err(|e| {
+                BlockSlashInfo::SignatureNotChecked(
+                    self.signed_block_header(),
+                    BlockError::AvailabilityCheck(e),
+                )
+            })?;
+        SignatureVerifiedBlock::check_slashable(
+            maybe_available,
+            block_root,
+            chain,
+        )?
+        .into_execution_pending_block_slashable(block_root, chain, notify_execution_layer)
     }
 
     fn block(&self) -> &SignedBeaconBlock<T::EthSpec> {
@@ -1321,7 +1174,7 @@ impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for Arc<SignedBeaconBlock
     }
 }
 
-impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for BlockWrapper<T::EthSpec> {
+impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for RpcBlock<T::EthSpec> {
     /// Verifies the `SignedBeaconBlock` by first transforming it into a `SignatureVerifiedBlock`
     /// and then using that implementation of `IntoExecutionPendingBlock` to complete verification.
     fn into_execution_pending_block_slashable(
@@ -1333,8 +1186,16 @@ impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for BlockWrapper<T::EthSp
         // Perform an early check to prevent wasting time on irrelevant blocks.
         let block_root = check_block_relevancy(self.as_block(), block_root, chain)
             .map_err(|e| BlockSlashInfo::SignatureNotChecked(self.signed_block_header(), e))?;
-
-        SignatureVerifiedBlock::check_slashable(self, block_root, chain)?
+        let maybe_available = chain
+            .data_availability_checker
+            .check_rpc_block_availability(self.clone())
+            .map_err(|e| {
+                BlockSlashInfo::SignatureNotChecked(
+                    self.signed_block_header(),
+                    BlockError::AvailabilityCheck(e),
+                )
+            })?;
+        SignatureVerifiedBlock::check_slashable(maybe_available, block_root, chain)?
             .into_execution_pending_block_slashable(block_root, chain, notify_execution_layer)
     }
 
@@ -1388,7 +1249,7 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
             //  because it will revert finalization. Note that the finalized block is stored in fork
             //  choice, so we will not reject any child of the finalized block (this is relevant during
             //  genesis).
-            return Err(BlockError::ParentUnknown(block.into_block_wrapper()));
+            return Err(BlockError::ParentUnknown(block.into_rpc_block()));
         }
 
         /*
@@ -1826,7 +1687,7 @@ pub fn check_block_is_finalized_checkpoint_or_descendant<
                 block_parent_root: block.parent_root(),
             })
         } else {
-            Err(BlockError::ParentUnknown(block.into_block_wrapper()))
+            Err(BlockError::ParentUnknown(block.into_rpc_block()))
         }
     }
 }
@@ -1898,8 +1759,8 @@ pub fn get_block_root<E: EthSpec>(block: &SignedBeaconBlock<E>) -> Hash256 {
 #[allow(clippy::type_complexity)]
 fn verify_parent_block_is_known<T: BeaconChainTypes>(
     chain: &BeaconChain<T>,
-    block: MaybeAvailableBlock<T::EthSpec>,
-) -> Result<(ProtoBlock, MaybeAvailableBlock<T::EthSpec>), BlockError<T::EthSpec>> {
+    block: Arc<SignedBeaconBlock<T::EthSpec>>,
+) -> Result<(ProtoBlock, Arc<SignedBeaconBlock<T::EthSpec>>), BlockError<T::EthSpec>> {
     if let Some(proto_block) = chain
         .canonical_head
         .fork_choice_read_lock()
@@ -1907,7 +1768,9 @@ fn verify_parent_block_is_known<T: BeaconChainTypes>(
     {
         Ok((proto_block, block))
     } else {
-        Err(BlockError::ParentUnknown(block.into_block_wrapper()))
+        Err(BlockError::ParentUnknown(RpcBlock::new_without_blobs(
+            block,
+        )))
     }
 }
 
@@ -1938,7 +1801,7 @@ fn load_parent<T: BeaconChainTypes, B: AsBlock<T::EthSpec>>(
         .fork_choice_read_lock()
         .contains_block(&block.parent_root())
     {
-        return Err(BlockError::ParentUnknown(block.into_block_wrapper()));
+        return Err(BlockError::ParentUnknown(block.into_rpc_block()));
     }
 
     let block_delay = chain
diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs
new file mode 100644
index 00000000000..a152b757df3
--- /dev/null
+++ b/beacon_node/beacon_chain/src/block_verification_types.rs
@@ -0,0 +1,404 @@
+use crate::blob_verification::GossipVerifiedBlobList;
+use crate::data_availability_checker::AvailabilityCheckError;
+pub use crate::data_availability_checker::{AvailableBlock, MaybeAvailableBlock};
+use crate::{data_availability_checker, GossipVerifiedBlock, PayloadVerificationOutcome};
+use derivative::Derivative;
+use ssz_derive::{Decode, Encode};
+use state_processing::ConsensusContext;
+use std::sync::Arc;
+use types::{
+    blob_sidecar::BlobIdentifier, ssz_tagged_beacon_state, ssz_tagged_signed_beacon_block,
+    ssz_tagged_signed_beacon_block_arc,
+};
+use types::{
+    BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarList, Epoch, EthSpec, Hash256,
+    SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
+};
+use crate::eth1_finalization_cache::Eth1FinalizationData;
+
+#[derive(Debug, Clone, Derivative)]
+#[derivative(Hash(bound = "E: EthSpec"))]
+pub struct RpcBlock<E: EthSpec> {
+    block: RpcBlockInner<E>,
+}
+
+#[derive(Debug, Clone, Derivative)]
+#[derivative(Hash(bound = "E: EthSpec"))]
+enum RpcBlockInner<E: EthSpec> {
+    /// Single block lookup response. This should potentially hit the data availability cache.
+    Block(Arc<SignedBeaconBlock<E>>),
+    /// This variant is used with parent lookups and by-range responses. It should have all blobs
+    /// ordered, all block roots matching, and the correct number of blobs for this block.
+    BlockAndBlobs(Arc<SignedBeaconBlock<E>>, BlobSidecarList<E>),
+}
+
+impl<E: EthSpec> RpcBlock<E> {
+    pub fn new_without_blobs(block: Arc<SignedBeaconBlock<E>>) -> Self {
+        Self {
+            block: RpcBlockInner::Block(block),
+        }
+    }
+
+    pub fn new(
+        block: Arc<SignedBeaconBlock<E>>,
+        blobs: Option<BlobSidecarList<E>>,
+    ) -> Result<Self, AvailabilityCheckError> {
+        if let Some(blobs) = blobs.as_ref() {
+            data_availability_checker::consistency_checks( &block, blobs)?;
+        }
+        let inner = match blobs {
+            Some(blobs) => RpcBlockInner::BlockAndBlobs(block, blobs),
+            None => RpcBlockInner::Block(block),
+        };
+        Ok(Self { block: inner })
+    }
+
+    pub fn deconstruct(self) -> (Arc<SignedBeaconBlock<E>>, Option<BlobSidecarList<E>>) {
+        match self.block {
+            RpcBlockInner::Block(block) => (block, None),
+            RpcBlockInner::BlockAndBlobs(block, blobs) => (block, Some(blobs)),
+        }
+    }
+    pub fn n_blobs(&self) -> usize {
+        match &self.block {
+            RpcBlockInner::Block(_) => 0,
+            RpcBlockInner::BlockAndBlobs(_, blobs) => blobs.len(),
+        }
+    }
+}
+
+impl<E: EthSpec> From<Arc<SignedBeaconBlock<E>>> for RpcBlock<E> {
+    fn from(value: Arc<SignedBeaconBlock<E>>) -> Self {
+        Self::new_without_blobs(value)
+    }
+}
+
+impl<E: EthSpec> From<SignedBeaconBlock<E>> for RpcBlock<E> {
+    fn from(value: SignedBeaconBlock<E>) -> Self {
+        Self::new_without_blobs(Arc::new(value))
+    }
+}
+
+pub enum ExecutedBlock<E: EthSpec> {
+    Available(AvailableExecutedBlock<E>),
+    AvailabilityPending(AvailabilityPendingExecutedBlock<E>),
+}
+
+impl<E: EthSpec> ExecutedBlock<E> {
+    pub fn new(
+        block: MaybeAvailableBlock<E>,
+        import_data: BlockImportData<E>,
+        payload_verification_outcome: PayloadVerificationOutcome,
+    ) -> Self {
+        match block {
+            MaybeAvailableBlock::Available(available_block) => {
+                Self::Available(AvailableExecutedBlock::new(
+                    available_block,
+                    import_data,
+                    payload_verification_outcome,
+                ))
+            }
+            MaybeAvailableBlock::AvailabilityPending(pending_block) => {
+                Self::AvailabilityPending(AvailabilityPendingExecutedBlock::new(
+                    pending_block,
+                    import_data,
+                    payload_verification_outcome,
+                ))
+            }
+        }
+    }
+
+    pub fn as_block(&self) -> &SignedBeaconBlock<E> {
+        match self {
+            Self::Available(available) => available.block.block(),
+            Self::AvailabilityPending(pending) => &pending.block,
+        }
+    }
+}
+
+#[derive(PartialEq)]
+pub struct AvailableExecutedBlock<E: EthSpec> {
+    pub block: AvailableBlock<E>,
+    pub import_data: BlockImportData<E>,
+    pub payload_verification_outcome: PayloadVerificationOutcome,
+}
+
+impl<E: EthSpec> AvailableExecutedBlock<E> {
+    pub fn new(
+        block: AvailableBlock<E>,
+        import_data: BlockImportData<E>,
+        payload_verification_outcome: PayloadVerificationOutcome,
+    ) -> Self {
+        Self {
+            block,
+            import_data,
+            payload_verification_outcome,
+        }
+    }
+
+    pub fn get_all_blob_ids(&self) -> Vec<BlobIdentifier> {
+        let num_blobs_expected = self
+            .block
+            .message()
+            .body()
+            .blob_kzg_commitments()
+            .map_or(0, |commitments| commitments.len());
+        let mut blob_ids = Vec::with_capacity(num_blobs_expected);
+        for i in 0..num_blobs_expected {
+            blob_ids.push(BlobIdentifier {
+                block_root: self.import_data.block_root,
+                index: i as u64,
+            });
+        }
+        blob_ids
+    }
+}
+
+#[derive(Encode, Decode, Clone)]
+pub struct AvailabilityPendingExecutedBlock<E: EthSpec> {
+    #[ssz(with = "ssz_tagged_signed_beacon_block_arc")]
+    pub block: Arc<SignedBeaconBlock<E>>,
+    pub import_data: BlockImportData<E>,
+    pub payload_verification_outcome: PayloadVerificationOutcome,
+}
+
+impl<E: EthSpec> AvailabilityPendingExecutedBlock<E> {
+    pub fn new(
+        block: Arc<SignedBeaconBlock<E>>,
+        import_data: BlockImportData<E>,
+        payload_verification_outcome: PayloadVerificationOutcome,
+    ) -> Self {
+        Self {
+            block,
+            import_data,
+            payload_verification_outcome,
+        }
+    }
+
+    pub fn num_blobs_expected(&self) -> usize {
+        self.block
+            .message()
+            .body()
+            .blob_kzg_commitments()
+            .map_or(0, |commitments| commitments.len())
+    }
+
+    pub fn get_all_blob_ids(&self) -> Vec<BlobIdentifier> {
+        let block_root = self.import_data.block_root;
+        self.block
+            .get_filtered_blob_ids(Some(block_root), |_, _| true)
+    }
+
+    pub fn get_filtered_blob_ids(
+        &self,
+        filter: impl Fn(usize, Hash256) -> bool,
+    ) -> Vec<BlobIdentifier> {
+        self.block
+            .get_filtered_blob_ids(Some(self.import_data.block_root), filter)
+    }
+}
+
+#[derive(Debug, PartialEq, Encode, Decode, Clone)]
+// TODO (mark): investigate using an Arc<state> / Arc<parent_block>
+//              here to make this cheaper to clone
+pub struct BlockImportData<E: EthSpec> {
+    pub block_root: Hash256,
+    #[ssz(with = "ssz_tagged_beacon_state")]
+    pub state: BeaconState<E>,
+    #[ssz(with = "ssz_tagged_signed_beacon_block")]
+    pub parent_block: SignedBeaconBlock<E, BlindedPayload<E>>,
+    pub parent_eth1_finalization_data: Eth1FinalizationData,
+    pub confirmed_state_roots: Vec<Hash256>,
+    pub consensus_context: ConsensusContext<E>,
+}
+
+pub type GossipVerifiedBlockContents<T> =
+    (GossipVerifiedBlock<T>, Option<GossipVerifiedBlobList<T>>);
+
+/// Trait for common block operations.
+pub trait AsBlock<E: EthSpec> {
+    fn slot(&self) -> Slot;
+    fn epoch(&self) -> Epoch;
+    fn parent_root(&self) -> Hash256;
+    fn state_root(&self) -> Hash256;
+    fn signed_block_header(&self) -> SignedBeaconBlockHeader;
+    fn message(&self) -> BeaconBlockRef<E>;
+    fn as_block(&self) -> &SignedBeaconBlock<E>;
+    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>>;
+    fn canonical_root(&self) -> Hash256;
+    fn into_rpc_block(self) -> RpcBlock<E>;
+}
+
+impl<E: EthSpec> AsBlock<E> for Arc<SignedBeaconBlock<E>> {
+    fn slot(&self) -> Slot {
+        SignedBeaconBlock::slot(self)
+    }
+
+    fn epoch(&self) -> Epoch {
+        SignedBeaconBlock::epoch(self)
+    }
+
+    fn parent_root(&self) -> Hash256 {
+        SignedBeaconBlock::parent_root(self)
+    }
+
+    fn state_root(&self) -> Hash256 {
+        SignedBeaconBlock::state_root(self)
+    }
+
+    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
+        SignedBeaconBlock::signed_block_header(self)
+    }
+
+    fn message(&self) -> BeaconBlockRef<E> {
+        SignedBeaconBlock::message(self)
+    }
+
+    fn as_block(&self) -> &SignedBeaconBlock<E> {
+        self
+    }
+
+    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
+        Arc::<SignedBeaconBlock<E>>::clone(self)
+    }
+
+    fn canonical_root(&self) -> Hash256 {
+        SignedBeaconBlock::canonical_root(self)
+    }
+
+    fn into_rpc_block(self) -> RpcBlock<E> {
+        RpcBlock::new_without_blobs(self)
+    }
+}
+
+impl<E: EthSpec> AsBlock<E> for MaybeAvailableBlock<E> {
+    fn slot(&self) -> Slot {
+        self.as_block().slot()
+    }
+    fn epoch(&self) -> Epoch {
+        self.as_block().epoch()
+    }
+    fn parent_root(&self) -> Hash256 {
+        self.as_block().parent_root()
+    }
+    fn state_root(&self) -> Hash256 {
+        self.as_block().state_root()
+    }
+    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
+        self.as_block().signed_block_header()
+    }
+    fn message(&self) -> BeaconBlockRef<E> {
+        self.as_block().message()
+    }
+    fn as_block(&self) -> &SignedBeaconBlock<E> {
+        match &self {
+            MaybeAvailableBlock::Available(block) => block.as_block(),
+            MaybeAvailableBlock::AvailabilityPending(block) => block,
+        }
+    }
+    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
+        match &self {
+            MaybeAvailableBlock::Available(block) => block.block_cloned(),
+            MaybeAvailableBlock::AvailabilityPending(block) => block.clone(),
+        }
+    }
+    fn canonical_root(&self) -> Hash256 {
+        self.as_block().canonical_root()
+    }
+
+    fn into_rpc_block(self) -> RpcBlock<E> {
+        match self {
+            MaybeAvailableBlock::Available(available_block) => available_block.into_rpc_block(),
+            MaybeAvailableBlock::AvailabilityPending(block) => RpcBlock::new_without_blobs(block),
+        }
+    }
+}
+
+impl<E: EthSpec> AsBlock<E> for AvailableBlock<E> {
+    fn slot(&self) -> Slot {
+        self.block().slot()
+    }
+
+    fn epoch(&self) -> Epoch {
+        self.block().epoch()
+    }
+
+    fn parent_root(&self) -> Hash256 {
+        self.block().parent_root()
+    }
+
+    fn state_root(&self) -> Hash256 {
+        self.block().state_root()
+    }
+
+    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
+        self.block().signed_block_header()
+    }
+
+    fn message(&self) -> BeaconBlockRef<E> {
+        self.block().message()
+    }
+
+    fn as_block(&self) -> &SignedBeaconBlock<E> {
+        self.block()
+    }
+
+    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
+        AvailableBlock::block_cloned(self)
+    }
+
+    fn canonical_root(&self) -> Hash256 {
+        self.block().canonical_root()
+    }
+
+    fn into_rpc_block(self) -> RpcBlock<E> {
+        let (block, blobs_opt) = self.deconstruct();
+        // Circumvent the constructor here, because an Available block will have already had
+        // consistency checks performed.
+        let inner = match blobs_opt {
+            None => RpcBlockInner::Block(block),
+            Some(blobs) => RpcBlockInner::BlockAndBlobs(block, blobs),
+        };
+        RpcBlock { block: inner }
+    }
+}
+
+impl<E: EthSpec> AsBlock<E> for RpcBlock<E> {
+    fn slot(&self) -> Slot {
+        self.as_block().slot()
+    }
+    fn epoch(&self) -> Epoch {
+        self.as_block().epoch()
+    }
+    fn parent_root(&self) -> Hash256 {
+        self.as_block().parent_root()
+    }
+    fn state_root(&self) -> Hash256 {
+        self.as_block().state_root()
+    }
+    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
+        self.as_block().signed_block_header()
+    }
+    fn message(&self) -> BeaconBlockRef<E> {
+        self.as_block().message()
+    }
+    fn as_block(&self) -> &SignedBeaconBlock<E> {
+        match &self.block {
+            RpcBlockInner::Block(block) => block,
+            RpcBlockInner::BlockAndBlobs(block, _) => block,
+        }
+    }
+    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
+        match &self.block {
+            RpcBlockInner::Block(block) => block.clone(),
+            RpcBlockInner::BlockAndBlobs(block, _) => block.clone(),
+        }
+    }
+    fn canonical_root(&self) -> Hash256 {
+        self.as_block().canonical_root()
+    }
+
+    fn into_rpc_block(self) -> RpcBlock<E> {
+        self
+    }
+}
\ No newline at end of file
diff --git a/beacon_node/beacon_chain/src/data_availability_checker.rs b/beacon_node/beacon_chain/src/data_availability_checker.rs
index fc48ba47ed8..eb33f64e911 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker.rs
@@ -1,28 +1,23 @@
 use crate::blob_verification::{
-    verify_kzg_for_blob, verify_kzg_for_blob_list, AsBlock, BlockWrapper, GossipVerifiedBlob,
-    KzgVerifiedBlob, KzgVerifiedBlobList, MaybeAvailableBlock,
+    verify_kzg_for_blob, verify_kzg_for_blob_list, GossipVerifiedBlob, KzgVerifiedBlob,
+};
+use crate::block_verification_types::{
+    AvailabilityPendingExecutedBlock, AvailableExecutedBlock, RpcBlock,
 };
-use crate::block_verification::{AvailabilityPendingExecutedBlock, AvailableExecutedBlock};
-
 use crate::data_availability_checker::overflow_lru_cache::OverflowLRUCache;
 use crate::{BeaconChain, BeaconChainTypes, BeaconStore};
 use kzg::Error as KzgError;
 use kzg::Kzg;
 use slog::{debug, error};
 use slot_clock::SlotClock;
-use ssz_types::{Error, FixedVector, VariableList};
+use ssz_types::{Error, VariableList};
 use std::collections::HashSet;
 use std::sync::Arc;
 use strum::IntoStaticStr;
 use task_executor::TaskExecutor;
-use types::beacon_block_body::KzgCommitments;
 use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
 use types::consts::deneb::MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS;
-use types::ssz_tagged_signed_beacon_block;
-use types::{
-    BeaconBlockRef, BlobSidecarList, ChainSpec, Epoch, EthSpec, FullPayload, Hash256,
-    SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
-};
+use types::{BlobSidecarList, ChainSpec, Epoch, EthSpec, Hash256, SignedBeaconBlock, Slot};
 
 mod overflow_lru_cache;
 
@@ -50,12 +45,20 @@ pub enum AvailabilityCheckError {
     },
     IncorrectFork,
     BlobIndexInvalid(u64),
+    UnorderedBlobs {
+        blob_index: u64,
+        expected_index: u64,
+    },
     StoreError(store::Error),
     DecodeError(ssz::DecodeError),
     BlockBlobRootMismatch {
         block_root: Hash256,
         blob_block_root: Hash256,
     },
+    BlockBlobSlotMismatch {
+        block_slot: Slot,
+        blob_slot: Slot,
+    },
 }
 
 impl From<ssz_types::Error> for AvailabilityCheckError {
@@ -92,7 +95,7 @@ pub struct DataAvailabilityChecker<T: BeaconChainTypes> {
 ///
 /// Indicates if the block is fully `Available` or if we need blobs or blocks
 ///  to "complete" the requirements for an `AvailableBlock`.
-#[derive(Debug, PartialEq)]
+#[derive(PartialEq)]
 pub enum Availability<T: EthSpec> {
     MissingComponents(Hash256),
     Available(Box<AvailableExecutedBlock<T>>),
@@ -230,86 +233,51 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
 
     /// Checks if a block is available, returns a `MaybeAvailableBlock` that may include the fully
     /// available block.
-    pub fn check_availability(
+    pub fn check_rpc_block_availability(
         &self,
-        block: BlockWrapper<T::EthSpec>,
+        block: RpcBlock<T::EthSpec>,
     ) -> Result<MaybeAvailableBlock<T::EthSpec>, AvailabilityCheckError> {
-        match block {
-            BlockWrapper::Block(block) => self.check_availability_without_blobs(block),
-            BlockWrapper::BlockAndBlobs(block, blob_list) => {
-                let kzg = self
-                    .kzg
-                    .as_ref()
-                    .ok_or(AvailabilityCheckError::KzgNotInitialized)?;
-                let filtered_blobs = blob_list.iter().flatten().cloned().collect();
-                let verified_blobs = verify_kzg_for_blob_list(filtered_blobs, kzg)?;
-
-                Ok(MaybeAvailableBlock::Available(
-                    self.check_availability_with_blobs(block, verified_blobs)?,
-                ))
+        let (block, blobs) = block.deconstruct();
+        match blobs {
+            None => {
+                if self.blobs_required_for_block(&block) {
+                    Ok(MaybeAvailableBlock::AvailabilityPending(block))
+                } else {
+                    Ok(MaybeAvailableBlock::Available(AvailableBlock {
+                        block,
+                        blobs: None,
+                    }))
+                }
             }
-        }
-    }
-
-    /// Verifies a block against a set of KZG verified blobs. Returns an AvailableBlock if block's
-    /// commitments are consistent with the provided verified blob commitments.
-    pub fn check_availability_with_blobs(
-        &self,
-        block: Arc<SignedBeaconBlock<T::EthSpec>>,
-        blobs: KzgVerifiedBlobList<T::EthSpec>,
-    ) -> Result<AvailableBlock<T::EthSpec>, AvailabilityCheckError> {
-        match self.check_availability_without_blobs(block)? {
-            MaybeAvailableBlock::Available(block) => Ok(block),
-            MaybeAvailableBlock::AvailabilityPending(pending_block) => {
-                pending_block.make_available(blobs)
+            Some(blob_list) => {
+                let verified_blobs = if self.blobs_required_for_block(&block) {
+                    let kzg = self
+                        .kzg
+                        .as_ref()
+                        .ok_or(AvailabilityCheckError::KzgNotInitialized)?;
+                    verify_kzg_for_blob_list(&blob_list, kzg)?;
+                    Some(blob_list)
+                } else {
+                    None
+                };
+                Ok(MaybeAvailableBlock::Available(AvailableBlock {
+                    block,
+                    blobs: verified_blobs,
+                }))
             }
         }
     }
 
-    /// Verifies a block as much as possible, returning a MaybeAvailableBlock enum that may include
-    /// an AvailableBlock if no blobs are required. Otherwise this will return an AvailabilityPendingBlock.
-    pub fn check_availability_without_blobs(
-        &self,
-        block: Arc<SignedBeaconBlock<T::EthSpec>>,
-    ) -> Result<MaybeAvailableBlock<T::EthSpec>, AvailabilityCheckError> {
-        let blob_requirements = self.get_blob_requirements(&block)?;
-        let blobs = match blob_requirements {
-            BlobRequirements::EmptyBlobs => VerifiedBlobs::EmptyBlobs,
-            BlobRequirements::NotRequired => VerifiedBlobs::NotRequired,
-            BlobRequirements::PreDeneb => VerifiedBlobs::PreDeneb,
-            BlobRequirements::Required => {
-                return Ok(MaybeAvailableBlock::AvailabilityPending(
-                    AvailabilityPendingBlock { block },
-                ))
-            }
-        };
-        Ok(MaybeAvailableBlock::Available(AvailableBlock {
-            block,
-            blobs,
-        }))
-    }
-
     /// Determines the blob requirements for a block. Answers the question: "Does this block require
     /// blobs?".
-    fn get_blob_requirements(
-        &self,
-        block: &Arc<SignedBeaconBlock<T::EthSpec, FullPayload<T::EthSpec>>>,
-    ) -> Result<BlobRequirements, AvailabilityCheckError> {
-        let verified_blobs =
-            if let Ok(block_kzg_commitments) = block.message().body().blob_kzg_commitments() {
-                if self.da_check_required(block.epoch()) {
-                    if block_kzg_commitments.is_empty() {
-                        BlobRequirements::EmptyBlobs
-                    } else {
-                        BlobRequirements::Required
-                    }
-                } else {
-                    BlobRequirements::NotRequired
-                }
-            } else {
-                BlobRequirements::PreDeneb
-            };
-        Ok(verified_blobs)
+    fn blobs_required_for_block(&self, block: &SignedBeaconBlock<T::EthSpec>) -> bool {
+        let block_within_da_period = self.da_check_required(block.epoch());
+        let block_has_kzg_commitments = block
+            .message()
+            .body()
+            .blob_kzg_commitments()
+            .map_or(false, |commitments| !commitments.is_empty());
+        block_within_da_period && block_has_kzg_commitments
     }
 
     /// The epoch at which we require a data availability check in block processing.
@@ -340,6 +308,77 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
     }
 }
 
+/// Verifies an `SignedBeaconBlock` against a set of KZG verified blobs.
+/// This does not check whether a block *should* have blobs, these checks should have been
+/// completed when producing the `AvailabilityPendingBlock`.
+pub fn make_available<T: EthSpec>(
+    block: Arc<SignedBeaconBlock<T>>,
+    blobs: Vec<KzgVerifiedBlob<T>>,
+) -> Result<AvailableBlock<T>, AvailabilityCheckError> {
+    let blobs = VariableList::new(blobs.into_iter().map(|blob| blob.to_blob()).collect())?;
+
+    consistency_checks( &block, &blobs)?;
+
+    Ok(AvailableBlock {
+        block,
+        blobs: Some(blobs),
+    })
+}
+
+pub fn consistency_checks<T: EthSpec>(
+    block: &SignedBeaconBlock<T>,
+    blobs: &[Arc<BlobSidecar<T>>],
+) -> Result<(), AvailabilityCheckError> {
+    let Ok(block_kzg_commitments) = block
+        .message()
+        .body()
+        .blob_kzg_commitments() else {
+        return Ok(())
+    };
+
+    if blobs.len() != block_kzg_commitments.len() {
+        return Err(AvailabilityCheckError::NumBlobsMismatch {
+            num_kzg_commitments: block_kzg_commitments.len(),
+            num_blobs: blobs.len(),
+        });
+    }
+
+    if block_kzg_commitments.is_empty() {
+        return Ok(());
+    }
+
+    let block_root = blobs.first().map(|blob|blob.block_root).unwrap_or(block.canonical_root());
+    for (index, (block_commitment, blob)) in
+        block_kzg_commitments.iter().zip(blobs.iter()).enumerate()
+    {
+        let index = index as u64;
+        if index != blob.index {
+            return Err(AvailabilityCheckError::UnorderedBlobs {
+                blob_index: blob.index,
+                expected_index: index,
+            });
+        }
+        if block_root != blob.block_root {
+            return Err(AvailabilityCheckError::BlockBlobRootMismatch {
+                block_root,
+                blob_block_root: blob.block_root,
+            });
+        }
+        if block.slot() != blob.slot {
+            return Err(AvailabilityCheckError::BlockBlobSlotMismatch {
+                block_slot: block.slot(),
+                blob_slot: blob.slot,
+            });
+        }
+        if *block_commitment != blob.kzg_commitment {
+            return Err(AvailabilityCheckError::KzgCommitmentMismatch {
+                blob_index: blob.index,
+            });
+        }
+    }
+    Ok(())
+}
+
 pub fn start_availability_cache_maintenance_service<T: BeaconChainTypes>(
     executor: TaskExecutor,
     chain: Arc<BeaconChain<T>>,
@@ -425,244 +464,37 @@ async fn availability_cache_maintenance_service<T: BeaconChainTypes>(
     }
 }
 
-pub enum BlobRequirements {
-    Required,
-    /// This block is from outside the data availability boundary so doesn't require
-    /// a data availability check.
-    NotRequired,
-    /// The block's `kzg_commitments` field is empty so it does not contain any blobs.
-    EmptyBlobs,
-    /// This is a block prior to the 4844 fork, so doesn't require any blobs
-    PreDeneb,
-}
-
-/// A wrapper over a `SignedBeaconBlock` where we have not verified availability of
-/// corresponding `BlobSidecar`s and hence, is not ready for import into fork choice.
-///
-/// Note: This wrapper does not necessarily correspond to a pre-deneb block as a pre-deneb
-/// block that is ready for import will be of type `AvailableBlock` with its `blobs` field
-/// set to `VerifiedBlobs::PreDeneb`.
-#[derive(Clone, Debug, PartialEq)]
-pub struct AvailabilityPendingBlock<E: EthSpec> {
-    block: Arc<SignedBeaconBlock<E>>,
-}
-
-impl<E: EthSpec> AvailabilityPendingBlock<E> {
-    pub fn slot(&self) -> Slot {
-        self.block.slot()
-    }
-    pub fn num_blobs_expected(&self) -> usize {
-        self.block.num_expected_blobs()
-    }
-
-    pub fn get_all_blob_ids(&self, block_root: Option<Hash256>) -> Vec<BlobIdentifier> {
-        self.block.get_expected_blob_ids(block_root)
-    }
-
-    pub fn get_filtered_blob_ids(
-        &self,
-        block_root: Option<Hash256>,
-        filter: impl Fn(usize, Hash256) -> bool,
-    ) -> Vec<BlobIdentifier> {
-        self.block.get_filtered_blob_ids(block_root, filter)
-    }
-}
-
-impl<E: EthSpec> AvailabilityPendingBlock<E> {
-    pub fn to_block(self) -> Arc<SignedBeaconBlock<E>> {
-        self.block
-    }
-    pub fn as_block(&self) -> &SignedBeaconBlock<E> {
-        &self.block
-    }
-    pub fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
-        self.block.clone()
-    }
-    pub fn kzg_commitments(&self) -> Result<&KzgCommitments<E>, AvailabilityCheckError> {
-        self.block
-            .message()
-            .body()
-            .blob_kzg_commitments()
-            .map_err(|_| AvailabilityCheckError::IncorrectFork)
-    }
-
-    /// Verifies an AvailabilityPendingBlock against a set of KZG verified blobs.
-    /// This does not check whether a block *should* have blobs, these checks should have been
-    /// completed when producing the `AvailabilityPendingBlock`.
-    pub fn make_available(
-        self,
-        blobs: Vec<KzgVerifiedBlob<E>>,
-    ) -> Result<AvailableBlock<E>, AvailabilityCheckError> {
-        let block_kzg_commitments = self.kzg_commitments()?;
-        if blobs.len() != block_kzg_commitments.len() {
-            return Err(AvailabilityCheckError::NumBlobsMismatch {
-                num_kzg_commitments: block_kzg_commitments.len(),
-                num_blobs: blobs.len(),
-            });
-        }
-
-        for (block_commitment, blob) in block_kzg_commitments.iter().zip(blobs.iter()) {
-            if *block_commitment != blob.kzg_commitment() {
-                return Err(AvailabilityCheckError::KzgCommitmentMismatch {
-                    blob_index: blob.as_blob().index,
-                });
-            }
-        }
-
-        let blobs = VariableList::new(blobs.into_iter().map(|blob| blob.to_blob()).collect())?;
-
-        Ok(AvailableBlock {
-            block: self.block,
-            blobs: VerifiedBlobs::Available(blobs),
-        })
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum VerifiedBlobs<E: EthSpec> {
-    /// These blobs are available.
-    Available(BlobSidecarList<E>),
-    /// This block is from outside the data availability boundary so doesn't require
-    /// a data availability check.
-    NotRequired,
-    /// The block's `kzg_commitments` field is empty so it does not contain any blobs.
-    EmptyBlobs,
-    /// This is a block prior to the 4844 fork, so doesn't require any blobs
-    PreDeneb,
-}
-
-impl<E: EthSpec> VerifiedBlobs<E> {
-    pub fn to_blobs(self) -> Option<BlobSidecarList<E>> {
-        match self {
-            Self::Available(blobs) => Some(blobs),
-            Self::NotRequired => None,
-            Self::EmptyBlobs => None,
-            Self::PreDeneb => None,
-        }
-    }
-}
-
 /// A fully available block that is ready to be imported into fork choice.
 #[derive(Clone, Debug, PartialEq)]
 pub struct AvailableBlock<E: EthSpec> {
     block: Arc<SignedBeaconBlock<E>>,
-    blobs: VerifiedBlobs<E>,
+    blobs: Option<BlobSidecarList<E>>,
 }
 
 impl<E: EthSpec> AvailableBlock<E> {
     pub fn block(&self) -> &SignedBeaconBlock<E> {
         &self.block
     }
-
-    pub fn da_check_required(&self) -> bool {
-        match self.blobs {
-            VerifiedBlobs::PreDeneb | VerifiedBlobs::NotRequired => false,
-            VerifiedBlobs::EmptyBlobs | VerifiedBlobs::Available(_) => true,
-        }
-    }
-
-    pub fn deconstruct(self) -> (Arc<SignedBeaconBlock<E>>, Option<BlobSidecarList<E>>) {
-        match self.blobs {
-            VerifiedBlobs::EmptyBlobs | VerifiedBlobs::NotRequired | VerifiedBlobs::PreDeneb => {
-                (self.block, None)
-            }
-            VerifiedBlobs::Available(blobs) => (self.block, Some(blobs)),
-        }
-    }
-
-    pub fn blobs(&self) -> Option<&BlobSidecarList<E>> {
-        match &self.blobs {
-            VerifiedBlobs::Available(blobs) => Some(blobs),
-            _ => None,
-        }
-    }
-}
-
-impl<E: EthSpec> AsBlock<E> for AvailableBlock<E> {
-    fn slot(&self) -> Slot {
-        self.block.slot()
-    }
-
-    fn epoch(&self) -> Epoch {
-        self.block.epoch()
-    }
-
-    fn parent_root(&self) -> Hash256 {
-        self.block.parent_root()
-    }
-
-    fn state_root(&self) -> Hash256 {
-        self.block.state_root()
-    }
-
-    fn signed_block_header(&self) -> SignedBeaconBlockHeader {
-        self.block.signed_block_header()
-    }
-
-    fn message(&self) -> BeaconBlockRef<E> {
-        self.block.message()
-    }
-
-    fn as_block(&self) -> &SignedBeaconBlock<E> {
-        &self.block
-    }
-
-    fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
+    pub fn block_cloned(&self) -> Arc<SignedBeaconBlock<E>> {
         self.block.clone()
     }
 
-    fn canonical_root(&self) -> Hash256 {
-        self.block.canonical_root()
-    }
-
-    fn into_block_wrapper(self) -> BlockWrapper<E> {
-        let (block, blobs_opt) = self.deconstruct();
-        if let Some(blobs) = blobs_opt {
-            let blobs_vec = blobs.iter().cloned().map(Option::Some).collect::<Vec<_>>();
-            BlockWrapper::BlockAndBlobs(block, FixedVector::from(blobs_vec))
-        } else {
-            BlockWrapper::Block(block)
-        }
-    }
-}
-
-// The standard implementation of Encode for SignedBeaconBlock
-// requires us to use ssz(enum_behaviour = "transparent"). This
-// prevents us from implementing Decode. We need to use a
-// custom Encode and Decode in this wrapper object that essentially
-// encodes it as if it were ssz(enum_behaviour = "union")
-impl<E: EthSpec> ssz::Encode for AvailabilityPendingBlock<E> {
-    fn is_ssz_fixed_len() -> bool {
-        ssz_tagged_signed_beacon_block::encode::is_ssz_fixed_len()
-    }
-
-    fn ssz_append(&self, buf: &mut Vec<u8>) {
-        ssz_tagged_signed_beacon_block::encode::ssz_append(self.block.as_ref(), buf);
-    }
-
-    fn ssz_bytes_len(&self) -> usize {
-        ssz_tagged_signed_beacon_block::encode::ssz_bytes_len(self.block.as_ref())
-    }
-}
-
-impl<E: EthSpec> ssz::Decode for AvailabilityPendingBlock<E> {
-    fn is_ssz_fixed_len() -> bool {
-        ssz_tagged_signed_beacon_block::decode::is_ssz_fixed_len()
+    pub fn blobs(&self) -> Option<&BlobSidecarList<E>> {
+        self.blobs.as_ref()
     }
 
-    fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
-        Ok(Self {
-            block: Arc::new(ssz_tagged_signed_beacon_block::decode::from_ssz_bytes(
-                bytes,
-            )?),
-        })
+    pub fn deconstruct(self) -> (Arc<SignedBeaconBlock<E>>, Option<BlobSidecarList<E>>) {
+        let AvailableBlock { block, blobs } = self;
+        (block, blobs)
     }
 }
 
-#[cfg(test)]
-mod test {
-    #[test]
-    fn check_encode_decode_availability_pending_block() {
-        // todo.. (difficult to create default beacon blocks to test)
-    }
+#[derive(Debug, Clone)]
+pub enum MaybeAvailableBlock<E: EthSpec> {
+    /// This variant is fully available.
+    /// i.e. for pre-deneb blocks, it contains a (`SignedBeaconBlock`, `Blobs::None`) and for
+    /// post-4844 blocks, it contains a `SignedBeaconBlock` and a Blobs variant other than `Blobs::None`.
+    Available(AvailableBlock<E>),
+    /// This variant is not fully available and requires blobs to become fully available.
+    AvailabilityPending(Arc<SignedBeaconBlock<E>>),
 }
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
index 6b99e62dea2..0b40df73a69 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
@@ -29,8 +29,10 @@
 
 use crate::beacon_chain::BeaconStore;
 use crate::blob_verification::KzgVerifiedBlob;
-use crate::block_verification::{AvailabilityPendingExecutedBlock, AvailableExecutedBlock};
-use crate::data_availability_checker::{Availability, AvailabilityCheckError};
+use crate::block_verification_types::{
+    AsBlock, AvailabilityPendingExecutedBlock, AvailableExecutedBlock,
+};
+use crate::data_availability_checker::{make_available, Availability, AvailabilityCheckError};
 use crate::store::{DBColumn, KeyValueStore};
 use crate::BeaconChainTypes;
 use lru::LruCache;
@@ -102,7 +104,7 @@ impl<T: EthSpec> PendingComponents<T> {
     pub fn epoch(&self) -> Option<Epoch> {
         self.executed_block
             .as_ref()
-            .map(|pending_block| pending_block.block.as_block().epoch())
+            .map(|pending_block| pending_block.block.epoch())
             .or_else(|| {
                 for maybe_blob in self.verified_blobs.iter() {
                     if maybe_blob.is_some() {
@@ -119,7 +121,7 @@ impl<T: EthSpec> PendingComponents<T> {
         let block_opt = self
             .executed_block
             .as_ref()
-            .map(|block| block.block.block.clone());
+            .map(|block| block.block.clone());
         let blobs = self
             .verified_blobs
             .iter()
@@ -538,7 +540,8 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
                             import_data,
                             payload_verification_outcome,
                         } = executed_block;
-                        let available_block = block.make_available(vec![])?;
+                        let available_block =
+                            make_available(block, vec![])?;
                         return Ok(Availability::Available(Box::new(
                             AvailableExecutedBlock::new(
                                 available_block,
@@ -588,7 +591,8 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
                  return Ok(Availability::MissingComponents(import_data.block_root))
             };
 
-            let available_block = block.make_available(verified_blobs)?;
+            let available_block =
+                make_available(block, verified_blobs)?;
             Ok(Availability::Available(Box::new(
                 AvailableExecutedBlock::new(
                     available_block,
@@ -758,7 +762,6 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
                                 value_bytes.as_slice(),
                             )?
                             .block
-                            .as_block()
                             .epoch()
                         }
                         OverflowKey::Blob(_, _) => {
@@ -854,8 +857,7 @@ mod test {
         blob_verification::{
             validate_blob_sidecar_for_gossip, verify_kzg_for_blob, GossipVerifiedBlob,
         },
-        block_verification::{BlockImportData, PayloadVerificationOutcome},
-        data_availability_checker::AvailabilityPendingBlock,
+        block_verification::PayloadVerificationOutcome,
         eth1_finalization_cache::Eth1FinalizationData,
         test_utils::{BaseHarnessType, BeaconChainHarness, DiskHarnessType},
     };
@@ -1137,10 +1139,6 @@ mod test {
         };
 
         let slot = block.slot();
-        let apb: AvailabilityPendingBlock<E> = AvailabilityPendingBlock {
-            block: Arc::new(block),
-        };
-
         let consensus_context = ConsensusContext::<E>::new(slot);
         let import_data: BlockImportData<E> = BlockImportData {
             block_root,
@@ -1157,7 +1155,7 @@ mod test {
         };
 
         let availability_pending_block = AvailabilityPendingExecutedBlock {
-            block: apb,
+            block: Arc::new(block),
             import_data,
             payload_verification_outcome,
         };
@@ -1473,7 +1471,7 @@ mod test {
                 // we need blocks with blobs
                 continue;
             }
-            let root = pending_block.block.as_block().canonical_root();
+            let root = pending_block.block.canonical_root();
             let epoch = pending_block
                 .block
                 .as_block()
diff --git a/beacon_node/beacon_chain/src/lib.rs b/beacon_node/beacon_chain/src/lib.rs
index f394cabe050..f7a9db11af7 100644
--- a/beacon_node/beacon_chain/src/lib.rs
+++ b/beacon_node/beacon_chain/src/lib.rs
@@ -12,6 +12,7 @@ pub mod blob_verification;
 pub mod block_reward;
 mod block_times_cache;
 mod block_verification;
+pub mod block_verification_types;
 pub mod builder;
 pub mod canonical_head;
 pub mod capella_readiness;
@@ -69,10 +70,12 @@ pub use self::historical_blocks::HistoricalBlockError;
 pub use attestation_verification::Error as AttestationError;
 pub use beacon_fork_choice_store::{BeaconForkChoiceStore, Error as ForkChoiceStoreError};
 pub use block_verification::{
-    get_block_root, AvailabilityPendingExecutedBlock, BlockError, ExecutedBlock,
-    ExecutionPayloadError, ExecutionPendingBlock, GossipVerifiedBlock, IntoExecutionPendingBlock,
-    IntoGossipVerifiedBlockContents, PayloadVerificationOutcome, PayloadVerificationStatus,
+    get_block_root, BlockError, ExecutionPayloadError, ExecutionPendingBlock, GossipVerifiedBlock,
+    IntoExecutionPendingBlock, IntoGossipVerifiedBlockContents, PayloadVerificationOutcome,
+    PayloadVerificationStatus,
 };
+pub use block_verification_types::AvailabilityPendingExecutedBlock;
+pub use block_verification_types::ExecutedBlock;
 pub use canonical_head::{CachedHead, CanonicalHead, CanonicalHeadRwLock};
 pub use eth1_chain::{Eth1Chain, Eth1ChainBackend};
 pub use events::ServerSentEventHandler;
diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
index 15331313b95..b2cea41cb45 100644
--- a/beacon_node/beacon_chain/src/test_utils.rs
+++ b/beacon_node/beacon_chain/src/test_utils.rs
@@ -1,4 +1,4 @@
-use crate::blob_verification::{AsBlock, BlockWrapper};
+use crate::block_verification_types::{AsBlock, RpcBlock};
 use crate::observed_operations::ObservationOutcome;
 pub use crate::persisted_beacon_chain::PersistedBeaconChain;
 pub use crate::{
@@ -689,18 +689,18 @@ where
             .execution_block_generator()
     }
 
-    pub fn get_head_block(&self) -> BlockWrapper<E> {
+    pub fn get_head_block(&self) -> RpcBlock<E> {
         let block = self.chain.head_beacon_block();
         let block_root = block.canonical_root();
         let blobs = self.chain.get_blobs(&block_root).unwrap();
-        BlockWrapper::new(block, blobs)
+        RpcBlock::new(block, blobs).unwrap()
     }
 
-    pub fn get_full_block(&self, block_root: &Hash256) -> BlockWrapper<E> {
+    pub fn get_full_block(&self, block_root: &Hash256) -> RpcBlock<E> {
         let block = self.chain.get_blinded_block(block_root).unwrap().unwrap();
         let full_block = self.chain.store.make_full_block(block_root, block).unwrap();
         let blobs = self.chain.get_blobs(block_root).unwrap();
-        BlockWrapper::new(Arc::new(full_block), blobs)
+        RpcBlock::new( Arc::new(full_block), blobs).unwrap()
     }
 
     pub fn get_all_validators(&self) -> Vec<usize> {
@@ -1868,7 +1868,7 @@ where
         (deposits, state)
     }
 
-    pub async fn process_block<B: Into<BlockWrapper<E>>>(
+    pub async fn process_block<B: Into<RpcBlock<E>>>(
         &self,
         slot: Slot,
         block_root: Hash256,
@@ -1887,7 +1887,7 @@ where
         Ok(block_hash)
     }
 
-    pub async fn process_block_result<B: Into<BlockWrapper<E>>>(
+    pub async fn process_block_result<B: Into<RpcBlock<E>>>(
         &self,
         block: B,
     ) -> Result<SignedBeaconBlockHash, BlockError<E>> {
@@ -1971,11 +1971,28 @@ where
         BlockError<E>,
     > {
         self.set_current_slot(slot);
-        let (block, new_state) = self.make_block(state, slot).await;
+        let ((block, blobs), new_state) = self.make_block(state, slot).await;
+        // Note: we are just dropping signatures here and skipping signature verification.
+        let blobs_without_signatures = blobs.as_ref().map(|blobs| {
+            VariableList::from(
+                blobs
+                    .into_iter()
+                    .map(|blob| blob.message.clone())
+                    .collect::<Vec<_>>(),
+            )
+        });
         let block_hash = self
-            .process_block(slot, block.0.canonical_root(), block.clone())
+            .process_block(
+                slot,
+                block.canonical_root(),
+                RpcBlock::new(
+                    Arc::new(block.clone()),
+                    blobs_without_signatures.clone(),
+                )
+                .unwrap(),
+            )
             .await?;
-        Ok((block_hash, block, new_state))
+        Ok((block_hash, (block, blobs), new_state))
     }
 
     pub fn attest_block(
diff --git a/beacon_node/beacon_chain/tests/attestation_production.rs b/beacon_node/beacon_chain/tests/attestation_production.rs
index 97122c00043..db3ddf3bf09 100644
--- a/beacon_node/beacon_chain/tests/attestation_production.rs
+++ b/beacon_node/beacon_chain/tests/attestation_production.rs
@@ -1,6 +1,6 @@
 #![cfg(not(debug_assertions))]
 
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::test_utils::{AttestationStrategy, BeaconChainHarness, BlockStrategy};
 use beacon_chain::{StateSkipConfig, WhenSlotSkipped};
 use lazy_static::lazy_static;
@@ -133,11 +133,10 @@ async fn produces_attestations() {
             assert_eq!(data.target.epoch, state.current_epoch(), "bad target epoch");
             assert_eq!(data.target.root, target_root, "bad target root");
 
-            let block_wrapper =
-                BlockWrapper::<MainnetEthSpec>::new(Arc::new(block.clone()), blobs.clone());
-            let beacon_chain::blob_verification::MaybeAvailableBlock::Available(available_block) = chain
+            let rpc_block = RpcBlock::<MainnetEthSpec>::new(Arc::new(block.clone()), blobs.clone()).unwrap();
+            let beacon_chain::data_availability_checker::MaybeAvailableBlock::Available(available_block) = chain
                 .data_availability_checker
-                .check_availability(block_wrapper)
+                .check_rpc_block_availability(rpc_block)
                 .unwrap()
                 else {
                     panic!("block should be available")
@@ -209,10 +208,10 @@ async fn early_attester_cache_old_request() {
         .get_blobs(&head.beacon_block_root)
         .expect("should get blobs");
 
-    let block_wrapper = BlockWrapper::<MainnetEthSpec>::new(head.beacon_block.clone(), head_blobs);
-    let beacon_chain::blob_verification::MaybeAvailableBlock::Available(available_block) = harness.chain
+    let rpc_block = RpcBlock::<MainnetEthSpec>::new(head.beacon_block.clone(), head_blobs).unwrap();
+    let beacon_chain::data_availability_checker::MaybeAvailableBlock::Available(available_block) = harness.chain
         .data_availability_checker
-        .check_availability(block_wrapper)
+        .check_rpc_block_availability(rpc_block)
         .unwrap()
         else {
             panic!("block should be available")
diff --git a/beacon_node/beacon_chain/tests/block_verification.rs b/beacon_node/beacon_chain/tests/block_verification.rs
index 37479236459..852e40834c4 100644
--- a/beacon_node/beacon_chain/tests/block_verification.rs
+++ b/beacon_node/beacon_chain/tests/block_verification.rs
@@ -1,12 +1,10 @@
 #![cfg(not(debug_assertions))]
 
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::{AsBlock, ExecutedBlock, RpcBlock};
 use beacon_chain::test_utils::BlobSignatureKey;
 use beacon_chain::{
-    blob_verification::AsBlock,
     test_utils::{AttestationStrategy, BeaconChainHarness, BlockStrategy, EphemeralHarnessType},
-    AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, ExecutedBlock,
-    ExecutionPendingBlock,
+    AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, ExecutionPendingBlock,
 };
 use beacon_chain::{
     BeaconSnapshot, BlockError, ChainSegmentResult, IntoExecutionPendingBlock, NotifyExecutionLayer,
@@ -156,11 +154,11 @@ fn get_harness(validator_count: usize) -> BeaconChainHarness<EphemeralHarnessTyp
 fn chain_segment_blocks(
     chain_segment: &[BeaconSnapshot<E>],
     blobs: &[Option<BlobSidecarList<E>>],
-) -> Vec<BlockWrapper<E>> {
+) -> Vec<RpcBlock<E>> {
     chain_segment
         .iter()
         .zip(blobs.into_iter())
-        .map(|(snapshot, blobs)| BlockWrapper::new(snapshot.beacon_block.clone(), blobs.clone()))
+        .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
         .collect()
 }
 
@@ -217,7 +215,7 @@ fn update_parent_roots(snapshots: &mut [BeaconSnapshot<E>]) {
 async fn chain_segment_full_segment() {
     let harness = get_harness(VALIDATOR_COUNT);
     let (chain_segment, chain_segment_blobs) = get_chain_segment().await;
-    let blocks: Vec<BlockWrapper<E>> = chain_segment_blocks(&chain_segment, &chain_segment_blobs)
+    let blocks: Vec<RpcBlock<E>> = chain_segment_blocks(&chain_segment, &chain_segment_blobs)
         .into_iter()
         .map(|block| block.into())
         .collect();
@@ -256,11 +254,10 @@ async fn chain_segment_varying_chunk_size() {
     for chunk_size in &[1, 2, 3, 5, 31, 32, 33, 42] {
         let harness = get_harness(VALIDATOR_COUNT);
         let (chain_segment, chain_segment_blobs) = get_chain_segment().await;
-        let blocks: Vec<BlockWrapper<E>> =
-            chain_segment_blocks(&chain_segment, &chain_segment_blobs)
-                .into_iter()
-                .map(|block| block.into())
-                .collect();
+        let blocks: Vec<RpcBlock<E>> = chain_segment_blocks(&chain_segment, &chain_segment_blobs)
+            .into_iter()
+            .map(|block| block.into())
+            .collect();
 
         harness
             .chain
@@ -299,11 +296,10 @@ async fn chain_segment_non_linear_parent_roots() {
     /*
      * Test with a block removed.
      */
-    let mut blocks: Vec<BlockWrapper<E>> =
-        chain_segment_blocks(&chain_segment, &chain_segment_blobs)
-            .into_iter()
-            .map(|block| block.into())
-            .collect();
+    let mut blocks: Vec<RpcBlock<E>> = chain_segment_blocks(&chain_segment, &chain_segment_blobs)
+        .into_iter()
+        .map(|block| block.into())
+        .collect();
     blocks.remove(2);
 
     assert!(
@@ -321,11 +317,10 @@ async fn chain_segment_non_linear_parent_roots() {
     /*
      * Test with a modified parent root.
      */
-    let mut blocks: Vec<BlockWrapper<E>> =
-        chain_segment_blocks(&chain_segment, &chain_segment_blobs)
-            .into_iter()
-            .map(|block| block.into())
-            .collect();
+    let mut blocks: Vec<RpcBlock<E>> = chain_segment_blocks(&chain_segment, &chain_segment_blobs)
+        .into_iter()
+        .map(|block| block.into())
+        .collect();
 
     let (mut block, signature) = blocks[3].as_block().clone().deconstruct();
     *block.parent_root_mut() = Hash256::zero();
@@ -357,11 +352,10 @@ async fn chain_segment_non_linear_slots() {
      * Test where a child is lower than the parent.
      */
 
-    let mut blocks: Vec<BlockWrapper<E>> =
-        chain_segment_blocks(&chain_segment, &chain_segment_blobs)
-            .into_iter()
-            .map(|block| block.into())
-            .collect();
+    let mut blocks: Vec<RpcBlock<E>> = chain_segment_blocks(&chain_segment, &chain_segment_blobs)
+        .into_iter()
+        .map(|block| block.into())
+        .collect();
     let (mut block, signature) = blocks[3].as_block().clone().deconstruct();
     *block.slot_mut() = Slot::new(0);
     blocks[3] = Arc::new(SignedBeaconBlock::from_block(block, signature)).into();
@@ -382,11 +376,10 @@ async fn chain_segment_non_linear_slots() {
      * Test where a child is equal to the parent.
      */
 
-    let mut blocks: Vec<BlockWrapper<E>> =
-        chain_segment_blocks(&chain_segment, &chain_segment_blobs)
-            .into_iter()
-            .map(|block| block.into())
-            .collect();
+    let mut blocks: Vec<RpcBlock<E>> = chain_segment_blocks(&chain_segment, &chain_segment_blobs)
+        .into_iter()
+        .map(|block| block.into())
+        .collect();
     let (mut block, signature) = blocks[3].as_block().clone().deconstruct();
     *block.slot_mut() = blocks[2].slot();
     blocks[3] = Arc::new(SignedBeaconBlock::from_block(block, signature)).into();
@@ -412,10 +405,10 @@ async fn assert_invalid_signature(
     snapshots: &[BeaconSnapshot<E>],
     item: &str,
 ) {
-    let blocks: Vec<BlockWrapper<E>> = snapshots
+    let blocks: Vec<RpcBlock<E>> = snapshots
         .iter()
         .zip(chain_segment_blobs.iter())
-        .map(|(snapshot, blobs)| BlockWrapper::new(snapshot.beacon_block.clone(), blobs.clone()))
+        .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
         .collect();
 
     // Ensure the block will be rejected if imported in a chain segment.
@@ -440,7 +433,7 @@ async fn assert_invalid_signature(
         .iter()
         .take(block_index)
         .zip(chain_segment_blobs.iter())
-        .map(|(snapshot, blobs)| BlockWrapper::new(snapshot.beacon_block.clone(), blobs.clone()))
+        .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
         .collect();
     // We don't care if this fails, we just call this to ensure that all prior blocks have been
     // imported prior to this test.
@@ -454,10 +447,10 @@ async fn assert_invalid_signature(
         .chain
         .process_block(
             snapshots[block_index].beacon_block.canonical_root(),
-            BlockWrapper::new(
+            RpcBlock::new(
                 snapshots[block_index].beacon_block.clone(),
                 chain_segment_blobs[block_index].clone(),
-            ),
+            ).unwrap(),
             NotifyExecutionLayer::Yes,
             || Ok(()),
         )
@@ -508,9 +501,7 @@ async fn invalid_signature_gossip_block() {
             .iter()
             .take(block_index)
             .zip(chain_segment_blobs.iter())
-            .map(|(snapshot, blobs)| {
-                BlockWrapper::new(snapshot.beacon_block.clone(), blobs.clone())
-            })
+            .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
             .collect();
         harness
             .chain
@@ -552,12 +543,10 @@ async fn invalid_signature_block_proposal() {
             block.clone(),
             junk_signature(),
         ));
-        let blocks: Vec<BlockWrapper<E>> = snapshots
+        let blocks: Vec<RpcBlock<E>> = snapshots
             .iter()
             .zip(chain_segment_blobs.iter())
-            .map(|(snapshot, blobs)| {
-                BlockWrapper::new(snapshot.beacon_block.clone(), blobs.clone())
-            })
+            .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
             .collect::<Vec<_>>();
         // Ensure the block will be rejected if imported in a chain segment.
         assert!(
@@ -765,12 +754,10 @@ async fn invalid_signature_deposit() {
             Arc::new(SignedBeaconBlock::from_block(block, signature));
         update_parent_roots(&mut snapshots);
         update_proposal_signatures(&mut snapshots, &harness);
-        let blocks: Vec<BlockWrapper<E>> = snapshots
+        let blocks: Vec<RpcBlock<E>> = snapshots
             .iter()
             .zip(chain_segment_blobs.iter())
-            .map(|(snapshot, blobs)| {
-                BlockWrapper::new(snapshot.beacon_block.clone(), blobs.clone())
-            })
+            .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
             .collect();
         assert!(
             !matches!(
diff --git a/beacon_node/beacon_chain/tests/store_tests.rs b/beacon_node/beacon_chain/tests/store_tests.rs
index 7a86b5f9382..d2b6a954520 100644
--- a/beacon_node/beacon_chain/tests/store_tests.rs
+++ b/beacon_node/beacon_chain/tests/store_tests.rs
@@ -1,7 +1,7 @@
 #![cfg(not(debug_assertions))]
 
 use beacon_chain::attestation_verification::Error as AttnError;
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::builder::BeaconChainBuilder;
 use beacon_chain::schema_change::migrate_schema;
 use beacon_chain::test_utils::{
@@ -10,7 +10,7 @@ use beacon_chain::test_utils::{
 };
 use beacon_chain::validator_monitor::DEFAULT_INDIVIDUAL_TRACKING_THRESHOLD;
 use beacon_chain::{
-    blob_verification::MaybeAvailableBlock, historical_blocks::HistoricalBlockError,
+    data_availability_checker::MaybeAvailableBlock, historical_blocks::HistoricalBlockError,
     migrate::MigratorConfig, BeaconChain, BeaconChainError, BeaconChainTypes, BeaconSnapshot,
     ChainConfig, NotifyExecutionLayer, ServerSentEventHandler, WhenSlotSkipped,
 };
@@ -2176,7 +2176,7 @@ async fn weak_subjectivity_sync() {
         beacon_chain
             .process_block(
                 full_block.canonical_root(),
-                BlockWrapper::new(Arc::new(full_block), blobs),
+                RpcBlock::new(Arc::new(full_block), blobs).unwrap(),
                 NotifyExecutionLayer::Yes,
                 || Ok(()),
             )
@@ -2236,7 +2236,7 @@ async fn weak_subjectivity_sync() {
         if let MaybeAvailableBlock::Available(block) = harness
             .chain
             .data_availability_checker
-            .check_availability(BlockWrapper::new(Arc::new(full_block), blobs))
+            .check_rpc_block_availability(RpcBlock::new(Arc::new(full_block), blobs).unwrap())
             .expect("should check availability")
         {
             available_blocks.push(block);
diff --git a/beacon_node/http_api/src/publish_blocks.rs b/beacon_node/http_api/src/publish_blocks.rs
index 54251608105..38c40b890db 100644
--- a/beacon_node/http_api/src/publish_blocks.rs
+++ b/beacon_node/http_api/src/publish_blocks.rs
@@ -1,6 +1,6 @@
 use crate::metrics;
 
-use beacon_chain::blob_verification::AsBlock;
+use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::validator_monitor::{get_block_delay_ms, timestamp_now};
 use beacon_chain::{
     AvailabilityProcessingStatus, BeaconChain, BeaconChainError, BeaconChainTypes, BlockError,
diff --git a/beacon_node/network/src/sync/backfill_sync/mod.rs b/beacon_node/network/src/sync/backfill_sync/mod.rs
index e5a1428005a..0900e034f00 100644
--- a/beacon_node/network/src/sync/backfill_sync/mod.rs
+++ b/beacon_node/network/src/sync/backfill_sync/mod.rs
@@ -14,7 +14,7 @@ use crate::sync::network_context::SyncNetworkContext;
 use crate::sync::range_sync::{
     BatchConfig, BatchId, BatchInfo, BatchOperationOutcome, BatchProcessingResult, BatchState,
 };
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
 use lighthouse_network::types::{BackFillState, NetworkGlobals};
 use lighthouse_network::{PeerAction, PeerId};
@@ -55,7 +55,7 @@ impl BatchConfig for BackFillBatchConfig {
     fn max_batch_processing_attempts() -> u8 {
         MAX_BATCH_PROCESSING_ATTEMPTS
     }
-    fn batch_attempt_hash<T: EthSpec>(blocks: &[BlockWrapper<T>]) -> u64 {
+    fn batch_attempt_hash<T: EthSpec>(blocks: &[RpcBlock<T>]) -> u64 {
         use std::collections::hash_map::DefaultHasher;
         use std::hash::{Hash, Hasher};
         let mut hasher = DefaultHasher::new();
@@ -392,7 +392,7 @@ impl<T: BeaconChainTypes> BackFillSync<T> {
         batch_id: BatchId,
         peer_id: &PeerId,
         request_id: Id,
-        beacon_block: Option<BlockWrapper<T::EthSpec>>,
+        beacon_block: Option<RpcBlock<T::EthSpec>>,
     ) -> Result<ProcessResult, BackFillError> {
         // check if we have this batch
         let batch = match self.batches.get_mut(&batch_id) {
diff --git a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
index 5175450d9e0..6d870b5aba3 100644
--- a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
@@ -3,8 +3,8 @@ use super::{BlobRequestId, BlockRequestId, DownloadedBlocks, PeerShouldHave, Res
 use crate::sync::block_lookups::single_block_lookup::{State, UnknownParentComponents};
 use crate::sync::block_lookups::{RootBlobsTuple, RootBlockTuple};
 use crate::sync::{manager::SLOT_IMPORT_TOLERANCE, network_context::SyncNetworkContext};
-use beacon_chain::blob_verification::AsBlock;
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::AsBlock;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::data_availability_checker::DataAvailabilityChecker;
 use beacon_chain::BeaconChainTypes;
 use lighthouse_network::PeerId;
@@ -147,7 +147,7 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
             .check_peer_disconnected(peer_id)
     }
 
-    pub fn add_unknown_parent_block(&mut self, block: BlockWrapper<T::EthSpec>) {
+    pub fn add_unknown_parent_block(&mut self, block: RpcBlock<T::EthSpec>) {
         let next_parent = block.parent_root();
 
         // Cache the block.
@@ -203,7 +203,7 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         self,
     ) -> (
         Hash256,
-        Vec<BlockWrapper<T::EthSpec>>,
+        Vec<RpcBlock<T::EthSpec>>,
         Vec<Hash256>,
         SingleBlockLookup<PARENT_FAIL_TOLERANCE, T>,
     ) {
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index b6e0cef8365..37b5ee0e767 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -1,6 +1,6 @@
 use crate::sync::block_lookups::{BlobRequestId, BlockRequestId, RootBlobsTuple, RootBlockTuple};
 use crate::sync::network_context::SyncNetworkContext;
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::data_availability_checker::DataAvailabilityChecker;
 use beacon_chain::{get_block_root, BeaconChainTypes};
 use lighthouse_network::rpc::methods::BlobsByRootRequest;
@@ -138,6 +138,16 @@ pub struct UnknownParentComponents<E: EthSpec> {
     pub downloaded_blobs: FixedBlobSidecarList<E>,
 }
 
+impl<E: EthSpec> From<RpcBlock<E>> for UnknownParentComponents<E> {
+    fn from(value: RpcBlock<E>) -> Self {
+        let (block, blobs) = value.deconstruct();
+        let fixed_blobs = blobs.map(|blobs| {
+            FixedBlobSidecarList::from(blobs.into_iter().map(Some).collect::<Vec<_>>())
+        });
+        Self::new(Some(block), fixed_blobs)
+    }
+}
+
 impl<E: EthSpec> UnknownParentComponents<E> {
     pub fn new(
         block: Option<Arc<SignedBeaconBlock<E>>>,
@@ -284,7 +294,7 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS
         };
     }
 
-    pub fn get_downloaded_block(&mut self) -> Option<BlockWrapper<T::EthSpec>> {
+    pub fn get_downloaded_block(&mut self) -> Option<RpcBlock<T::EthSpec>> {
         self.unknown_parent_components
             .as_mut()
             .and_then(|components| {
@@ -302,9 +312,14 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS
                         downloaded_block,
                         downloaded_blobs,
                     } = components;
-                    downloaded_block.as_ref().map(|block| {
-                        BlockWrapper::BlockAndBlobs(block.clone(), std::mem::take(downloaded_blobs))
-                    })
+                    downloaded_block.as_ref().and_then(|block| {
+                                            //TODO(sean) figure out how to properly deal with a consistency error here,
+                                                // should we downscore the peer sending blobs?
+                                                let blobs = std::mem::take(downloaded_blobs);
+                                            let filtered=blobs.into_iter().filter_map(|b|b.clone()).collect::<Vec<_>>();
+                                            let blobs = VariableList::from(filtered);
+                                            RpcBlock::new(block.clone(), Some(blobs)).ok()
+                                        })
                 } else {
                     None
                 }
diff --git a/beacon_node/network/src/sync/block_lookups/tests.rs b/beacon_node/network/src/sync/block_lookups/tests.rs
index c8f19b16981..482254d9ced 100644
--- a/beacon_node/network/src/sync/block_lookups/tests.rs
+++ b/beacon_node/network/src/sync/block_lookups/tests.rs
@@ -1474,7 +1474,7 @@ mod deneb_only {
         fn parent_block_unknown_parent(mut self) -> Self {
             self.bl.parent_block_processed(
                 self.block_root,
-                BlockProcessingResult::Err(BlockError::ParentUnknown(BlockWrapper::Block(
+                BlockProcessingResult::Err(BlockError::ParentUnknown(RpcBlock::new_without_blobs(
                     self.parent_block.clone().expect("parent block"),
                 ))),
                 ResponseType::Block,
diff --git a/beacon_node/network/src/sync/block_sidecar_coupling.rs b/beacon_node/network/src/sync/block_sidecar_coupling.rs
index 7e5362a6f0d..b25dcdf334e 100644
--- a/beacon_node/network/src/sync/block_sidecar_coupling.rs
+++ b/beacon_node/network/src/sync/block_sidecar_coupling.rs
@@ -1,5 +1,5 @@
-use beacon_chain::blob_verification::BlockWrapper;
-use ssz_types::FixedVector;
+use beacon_chain::block_verification_types::RpcBlock;
+use ssz_types::{VariableList};
 use std::{collections::VecDeque, sync::Arc};
 use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
 
@@ -16,28 +16,28 @@ pub struct BlocksAndBlobsRequestInfo<T: EthSpec> {
 }
 
 impl<T: EthSpec> BlocksAndBlobsRequestInfo<T> {
-    pub fn add_block_response(&mut self, maybe_block: Option<Arc<SignedBeaconBlock<T>>>) {
-        match maybe_block {
+    pub fn add_block_response(&mut self, block_opt: Option<Arc<SignedBeaconBlock<T>>>) {
+        match block_opt {
             Some(block) => self.accumulated_blocks.push_back(block),
             None => self.is_blocks_stream_terminated = true,
         }
     }
 
-    pub fn add_sidecar_response(&mut self, maybe_sidecar: Option<Arc<BlobSidecar<T>>>) {
-        match maybe_sidecar {
+    pub fn add_sidecar_response(&mut self, sidecar_opt: Option<Arc<BlobSidecar<T>>>) {
+        match sidecar_opt {
             Some(sidecar) => self.accumulated_sidecars.push_back(sidecar),
             None => self.is_sidecars_stream_terminated = true,
         }
     }
 
-    pub fn into_responses(self) -> Result<Vec<BlockWrapper<T>>, &'static str> {
+    pub fn into_responses(self) -> Result<Vec<RpcBlock<T>>, &'static str> {
         let BlocksAndBlobsRequestInfo {
             accumulated_blocks,
             accumulated_sidecars,
             ..
         } = self;
 
-        // ASSUMPTION: There can't be more more blobs than blocks. i.e. sending any blob (empty
+        // There can't be more more blobs than blocks. i.e. sending any blob (empty
         // included) for a skipped slot is not permitted.
         let mut responses = Vec::with_capacity(accumulated_blocks.len());
         let mut blob_iter = accumulated_sidecars.into_iter().peekable();
@@ -50,29 +50,23 @@ impl<T: EthSpec> BlocksAndBlobsRequestInfo<T> {
                     .unwrap_or(false);
                 pair_next_blob
             } {
-                blob_list.push(blob_iter.next().expect("iterator is not empty"));
+                blob_list.push(blob_iter.next().ok_or("Missing next blob")?);
             }
 
-            if blob_list.is_empty() {
-                responses.push(BlockWrapper::Block(block))
-            } else {
-                let mut blobs_fixed = vec![None; T::max_blobs_per_block()];
-                for blob in blob_list {
-                    let blob_index = blob.index as usize;
-                    let Some(blob_opt) = blobs_fixed.get_mut(blob_index) else {
+            let mut blobs_buffer = vec![None; T::max_blobs_per_block()];
+            for blob in blob_list {
+                let blob_index = blob.index as usize;
+                let Some(blob_opt) = blobs_buffer.get_mut(blob_index) else {
                         return Err("Invalid blob index");
                     };
-                    if blob_opt.is_some() {
-                        return Err("Repeat blob index");
-                    } else {
-                        *blob_opt = Some(blob);
-                    }
+                if blob_opt.is_some() {
+                    return Err("Repeat blob index");
+                } else {
+                    *blob_opt = Some(blob);
                 }
-                responses.push(BlockWrapper::BlockAndBlobs(
-                    block,
-                    FixedVector::from(blobs_fixed),
-                ))
             }
+            let blobs = VariableList::from(blobs_buffer.into_iter().flatten().collect::<Vec<_>>());
+            responses.push(RpcBlock::new(block, Some(blobs))?)
         }
 
         // if accumulated sidecars is not empty, throw an error.
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index 8bdf57e2a41..5e8fc4a4e9e 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -46,8 +46,8 @@ use crate::sync::block_lookups::delayed_lookup::DelayedLookupMessage;
 pub use crate::sync::block_lookups::ResponseType;
 use crate::sync::block_lookups::UnknownParentComponents;
 use crate::sync::range_sync::ByRangeRequestType;
-use beacon_chain::blob_verification::AsBlock;
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::AsBlock;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{
     AvailabilityProcessingStatus, BeaconChain, BeaconChainTypes, BlockError, EngineState,
     MAXIMUM_GOSSIP_CLOCK_DISPARITY,
@@ -614,15 +614,13 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             } => self.rpc_blob_received(request_id, peer_id, blob_sidecar, seen_timestamp),
             SyncMessage::UnknownParentBlock(peer_id, block, block_root) => {
                 let block_slot = block.slot();
-                let (block, blobs) = block.deconstruct();
                 let parent_root = block.parent_root();
-                let parent_components = UnknownParentComponents::new(Some(block), blobs);
                 self.handle_unknown_parent(
                     peer_id,
                     block_root,
                     parent_root,
                     block_slot,
-                    Some(parent_components),
+                    Some(block.into()),
                 );
             }
             SyncMessage::UnknownParentBlob(peer_id, blob) => {
@@ -910,7 +908,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                         batch_id,
                         &peer_id,
                         id,
-                        block.map(BlockWrapper::Block),
+                        block.map(Into::into),
                     ) {
                         Ok(ProcessResult::SyncCompleted) => self.update_sync_state(),
                         Ok(ProcessResult::Successful) => {}
@@ -934,7 +932,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                         chain_id,
                         batch_id,
                         id,
-                        block.map(BlockWrapper::Block),
+                        block.map(Into::into),
                     );
                     self.update_sync_state();
                 }
diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs
index 7c162f478c5..d635dd2ea18 100644
--- a/beacon_node/network/src/sync/network_context.rs
+++ b/beacon_node/network/src/sync/network_context.rs
@@ -8,7 +8,7 @@ use crate::network_beacon_processor::NetworkBeaconProcessor;
 use crate::service::{NetworkMessage, RequestId};
 use crate::status::ToStatusMessage;
 use crate::sync::block_lookups::{BlobRequestId, BlockRequestId};
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{BeaconChain, BeaconChainTypes, EngineState};
 use fnv::FnvHashMap;
 use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
@@ -22,7 +22,7 @@ use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
 
 pub struct BlocksAndBlobsByRangeResponse<T: EthSpec> {
     pub batch_id: BatchId,
-    pub responses: Result<Vec<BlockWrapper<T>>, &'static str>,
+    pub responses: Result<Vec<RpcBlock<T>>, &'static str>,
 }
 
 pub struct BlocksAndBlobsByRangeRequest<T: EthSpec> {
diff --git a/beacon_node/network/src/sync/range_sync/batch.rs b/beacon_node/network/src/sync/range_sync/batch.rs
index 138d320965e..f5c320cb880 100644
--- a/beacon_node/network/src/sync/range_sync/batch.rs
+++ b/beacon_node/network/src/sync/range_sync/batch.rs
@@ -1,5 +1,5 @@
 use crate::sync::manager::Id;
-use beacon_chain::blob_verification::{AsBlock, BlockWrapper};
+use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
 use lighthouse_network::rpc::methods::BlocksByRangeRequest;
 use lighthouse_network::PeerId;
 use std::collections::HashSet;
@@ -56,7 +56,7 @@ pub trait BatchConfig {
     /// Note that simpler hashing functions considered in the past (hash of first block, hash of last
     /// block, number of received blocks) are not good enough to differentiate attempts. For this
     /// reason, we hash the complete set of blocks both in RangeSync and BackFillSync.
-    fn batch_attempt_hash<T: EthSpec>(blocks: &[BlockWrapper<T>]) -> u64;
+    fn batch_attempt_hash<T: EthSpec>(blocks: &[RpcBlock<T>]) -> u64;
 }
 
 pub struct RangeSyncBatchConfig {}
@@ -68,7 +68,7 @@ impl BatchConfig for RangeSyncBatchConfig {
     fn max_batch_processing_attempts() -> u8 {
         MAX_BATCH_PROCESSING_ATTEMPTS
     }
-    fn batch_attempt_hash<T: EthSpec>(blocks: &[BlockWrapper<T>]) -> u64 {
+    fn batch_attempt_hash<T: EthSpec>(blocks: &[RpcBlock<T>]) -> u64 {
         let mut hasher = std::collections::hash_map::DefaultHasher::new();
         blocks.hash(&mut hasher);
         hasher.finish()
@@ -116,9 +116,9 @@ pub enum BatchState<T: EthSpec> {
     /// The batch has failed either downloading or processing, but can be requested again.
     AwaitingDownload,
     /// The batch is being downloaded.
-    Downloading(PeerId, Vec<BlockWrapper<T>>, Id),
+    Downloading(PeerId, Vec<RpcBlock<T>>, Id),
     /// The batch has been completely downloaded and is ready for processing.
-    AwaitingProcessing(PeerId, Vec<BlockWrapper<T>>),
+    AwaitingProcessing(PeerId, Vec<RpcBlock<T>>),
     /// The batch is being processed.
     Processing(Attempt),
     /// The batch was successfully processed and is waiting to be validated.
@@ -251,7 +251,7 @@ impl<T: EthSpec, B: BatchConfig> BatchInfo<T, B> {
     }
 
     /// Adds a block to a downloading batch.
-    pub fn add_block(&mut self, block: BlockWrapper<T>) -> Result<(), WrongState> {
+    pub fn add_block(&mut self, block: RpcBlock<T>) -> Result<(), WrongState> {
         match self.state.poison() {
             BatchState::Downloading(peer, mut blocks, req_id) => {
                 blocks.push(block);
@@ -383,7 +383,7 @@ impl<T: EthSpec, B: BatchConfig> BatchInfo<T, B> {
         }
     }
 
-    pub fn start_processing(&mut self) -> Result<Vec<BlockWrapper<T>>, WrongState> {
+    pub fn start_processing(&mut self) -> Result<Vec<RpcBlock<T>>, WrongState> {
         match self.state.poison() {
             BatchState::AwaitingProcessing(peer, blocks) => {
                 self.state = BatchState::Processing(Attempt::new::<B, T>(peer, &blocks));
@@ -481,7 +481,7 @@ pub struct Attempt {
 }
 
 impl Attempt {
-    fn new<B: BatchConfig, T: EthSpec>(peer_id: PeerId, blocks: &[BlockWrapper<T>]) -> Self {
+    fn new<B: BatchConfig, T: EthSpec>(peer_id: PeerId, blocks: &[RpcBlock<T>]) -> Self {
         let hash = B::batch_attempt_hash(blocks);
         Attempt { peer_id, hash }
     }
diff --git a/beacon_node/network/src/sync/range_sync/chain.rs b/beacon_node/network/src/sync/range_sync/chain.rs
index 3b3cdb6ae3b..4d399b5cb99 100644
--- a/beacon_node/network/src/sync/range_sync/chain.rs
+++ b/beacon_node/network/src/sync/range_sync/chain.rs
@@ -3,7 +3,7 @@ use crate::network_beacon_processor::ChainSegmentProcessId;
 use crate::sync::{
     manager::Id, network_context::SyncNetworkContext, BatchOperationOutcome, BatchProcessResult,
 };
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::BeaconChainTypes;
 use fnv::FnvHashMap;
 use lighthouse_network::{PeerAction, PeerId};
@@ -221,7 +221,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
         batch_id: BatchId,
         peer_id: &PeerId,
         request_id: Id,
-        beacon_block: Option<BlockWrapper<T::EthSpec>>,
+        beacon_block: Option<RpcBlock<T::EthSpec>>,
     ) -> ProcessingResult {
         // check if we have this batch
         let batch = match self.batches.get_mut(&batch_id) {
diff --git a/beacon_node/network/src/sync/range_sync/range.rs b/beacon_node/network/src/sync/range_sync/range.rs
index 09a85208d96..f69a30b3ee0 100644
--- a/beacon_node/network/src/sync/range_sync/range.rs
+++ b/beacon_node/network/src/sync/range_sync/range.rs
@@ -47,7 +47,7 @@ use crate::status::ToStatusMessage;
 use crate::sync::manager::Id;
 use crate::sync::network_context::SyncNetworkContext;
 use crate::sync::BatchProcessResult;
-use beacon_chain::blob_verification::BlockWrapper;
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
 use lighthouse_network::rpc::GoodbyeReason;
 use lighthouse_network::PeerId;
@@ -210,7 +210,7 @@ where
         chain_id: ChainId,
         batch_id: BatchId,
         request_id: Id,
-        beacon_block: Option<BlockWrapper<T::EthSpec>>,
+        beacon_block: Option<RpcBlock<T::EthSpec>>,
     ) {
         // check if this chunk removes the chain
         match self.chains.call_by_id(chain_id, |chain| {
@@ -394,7 +394,6 @@ mod tests {
     use lighthouse_network::{rpc::StatusMessage, NetworkGlobals};
     use slog::{o, Drain};
     use tokio::sync::mpsc;
-
     use beacon_chain::test_utils::{BeaconChainHarness, EphemeralHarnessType};
     use slot_clock::{TestingSlotClock, };
     use std::collections::HashSet;
diff --git a/consensus/fork_choice/tests/tests.rs b/consensus/fork_choice/tests/tests.rs
index 88fb7d8965e..bba7ccdbe67 100644
--- a/consensus/fork_choice/tests/tests.rs
+++ b/consensus/fork_choice/tests/tests.rs
@@ -11,6 +11,7 @@ use beacon_chain::{
     BeaconChain, BeaconChainError, BeaconForkChoiceStore, ChainConfig, ForkChoiceError,
     StateSkipConfig, WhenSlotSkipped,
 };
+use beacon_chain::block_verification_types::RpcBlock;
 use fork_choice::{
     ForkChoiceStore, InvalidAttestation, InvalidBlock, PayloadVerificationStatus, QueuedAttestation,
 };
@@ -200,7 +201,7 @@ impl ForkChoiceTest {
             if !predicate(block.0.message(), &state) {
                 break;
             }
-            if let Ok(block_hash) = self.harness.process_block_result(block.clone()).await {
+            if let Ok(block_hash) = self.harness.process_block_result(RpcBlock::new(block.0, block.1).unwrap()).await {
                 self.harness.attest_block(
                     &state,
                     block.0.state_root(),
diff --git a/consensus/state_processing/src/consensus_context.rs b/consensus/state_processing/src/consensus_context.rs
index 78803ab4eb4..8e49a0d4983 100644
--- a/consensus/state_processing/src/consensus_context.rs
+++ b/consensus/state_processing/src/consensus_context.rs
@@ -21,8 +21,6 @@ pub struct ConsensusContext<T: EthSpec> {
     #[ssz(skip_serializing, skip_deserializing)]
     indexed_attestations:
         HashMap<(AttestationData, BitList<T::MaxValidatorsPerCommittee>), IndexedAttestation<T>>,
-    /// Whether `verify_kzg_commitments_against_transactions` has successfully passed.
-    kzg_commitments_consistent: bool,
 }
 
 #[derive(Debug, PartialEq, Clone)]
@@ -45,7 +43,6 @@ impl<T: EthSpec> ConsensusContext<T> {
             proposer_index: None,
             current_block_root: None,
             indexed_attestations: HashMap::new(),
-            kzg_commitments_consistent: false,
         }
     }
 
@@ -161,13 +158,4 @@ impl<T: EthSpec> ConsensusContext<T> {
     pub fn num_cached_indexed_attestations(&self) -> usize {
         self.indexed_attestations.len()
     }
-
-    pub fn set_kzg_commitments_consistent(mut self, kzg_commitments_consistent: bool) -> Self {
-        self.kzg_commitments_consistent = kzg_commitments_consistent;
-        self
-    }
-
-    pub fn kzg_commitments_consistent(&self) -> bool {
-        self.kzg_commitments_consistent
-    }
 }
diff --git a/consensus/types/src/lib.rs b/consensus/types/src/lib.rs
index fe07a9c0ff8..def9f30f8d0 100644
--- a/consensus/types/src/lib.rs
+++ b/consensus/types/src/lib.rs
@@ -169,9 +169,10 @@ pub use crate::selection_proof::SelectionProof;
 pub use crate::shuffling_id::AttestationShufflingId;
 pub use crate::signed_aggregate_and_proof::SignedAggregateAndProof;
 pub use crate::signed_beacon_block::{
-    ssz_tagged_signed_beacon_block, SignedBeaconBlock, SignedBeaconBlockAltair,
-    SignedBeaconBlockBase, SignedBeaconBlockCapella, SignedBeaconBlockDeneb, SignedBeaconBlockHash,
-    SignedBeaconBlockMerge, SignedBlindedBeaconBlock,
+    ssz_tagged_signed_beacon_block, ssz_tagged_signed_beacon_block_arc, SignedBeaconBlock,
+    SignedBeaconBlockAltair, SignedBeaconBlockBase, SignedBeaconBlockCapella,
+    SignedBeaconBlockDeneb, SignedBeaconBlockHash, SignedBeaconBlockMerge,
+    SignedBlindedBeaconBlock,
 };
 pub use crate::signed_beacon_block_header::SignedBeaconBlockHeader;
 pub use crate::signed_blob::*;
diff --git a/consensus/types/src/signed_beacon_block.rs b/consensus/types/src/signed_beacon_block.rs
index cf7fd6819ea..c52ba11d278 100644
--- a/consensus/types/src/signed_beacon_block.rs
+++ b/consensus/types/src/signed_beacon_block.rs
@@ -642,6 +642,27 @@ pub mod ssz_tagged_signed_beacon_block {
     }
 }
 
+pub mod ssz_tagged_signed_beacon_block_arc {
+    use super::*;
+    pub mod encode {
+        pub use super::ssz_tagged_signed_beacon_block::encode::*;
+    }
+
+    pub mod decode {
+        pub use super::ssz_tagged_signed_beacon_block::decode::{is_ssz_fixed_len, ssz_fixed_len};
+        use super::*;
+        #[allow(unused_imports)]
+        use ssz::*;
+        use std::sync::Arc;
+
+        pub fn from_ssz_bytes<E: EthSpec, Payload: AbstractExecPayload<E>>(
+            bytes: &[u8],
+        ) -> Result<Arc<SignedBeaconBlock<E, Payload>>, DecodeError> {
+            ssz_tagged_signed_beacon_block::decode::from_ssz_bytes(bytes).map(Arc::new)
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

From e3ee0c6cceb22db9684a8e8bef5667f0e4e369f1 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Fri, 14 Jul 2023 17:29:41 -0400
Subject: [PATCH 03/18] cargo fmt

---
 .../beacon_chain/src/block_verification.rs    |  8 ++----
 .../src/block_verification_types.rs           |  6 ++---
 .../src/data_availability_checker.rs          |  7 +++--
 .../overflow_lru_cache.rs                     |  6 ++---
 beacon_node/beacon_chain/src/test_utils.rs    |  8 ++----
 .../tests/attestation_production.rs           |  3 ++-
 .../beacon_chain/tests/block_verification.rs  | 27 ++++++++++++++-----
 .../src/network_beacon_processor/mod.rs       | 20 +++-----------
 .../network_beacon_processor/sync_methods.rs  |  7 ++---
 .../src/network_beacon_processor/tests.rs     | 18 +++++++------
 beacon_node/network/src/router.rs             | 16 ++++-------
 beacon_node/network/src/service/tests.rs      |  2 +-
 .../src/sync/block_lookups/delayed_lookup.rs  |  6 ++---
 .../sync/block_lookups/single_block_lookup.rs | 17 +++++++-----
 .../src/sync/block_sidecar_coupling.rs        |  2 +-
 .../network/src/sync/range_sync/range.rs      |  6 ++---
 consensus/fork_choice/tests/tests.rs          |  8 ++++--
 17 files changed, 83 insertions(+), 84 deletions(-)

diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
index dfe388417f9..c9e0ee4c9d2 100644
--- a/beacon_node/beacon_chain/src/block_verification.rs
+++ b/beacon_node/beacon_chain/src/block_verification.rs
@@ -1161,12 +1161,8 @@ impl<T: BeaconChainTypes> IntoExecutionPendingBlock<T> for Arc<SignedBeaconBlock
                     BlockError::AvailabilityCheck(e),
                 )
             })?;
-        SignatureVerifiedBlock::check_slashable(
-            maybe_available,
-            block_root,
-            chain,
-        )?
-        .into_execution_pending_block_slashable(block_root, chain, notify_execution_layer)
+        SignatureVerifiedBlock::check_slashable(maybe_available, block_root, chain)?
+            .into_execution_pending_block_slashable(block_root, chain, notify_execution_layer)
     }
 
     fn block(&self) -> &SignedBeaconBlock<T::EthSpec> {
diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs
index a152b757df3..d88275b18ae 100644
--- a/beacon_node/beacon_chain/src/block_verification_types.rs
+++ b/beacon_node/beacon_chain/src/block_verification_types.rs
@@ -1,6 +1,7 @@
 use crate::blob_verification::GossipVerifiedBlobList;
 use crate::data_availability_checker::AvailabilityCheckError;
 pub use crate::data_availability_checker::{AvailableBlock, MaybeAvailableBlock};
+use crate::eth1_finalization_cache::Eth1FinalizationData;
 use crate::{data_availability_checker, GossipVerifiedBlock, PayloadVerificationOutcome};
 use derivative::Derivative;
 use ssz_derive::{Decode, Encode};
@@ -14,7 +15,6 @@ use types::{
     BeaconBlockRef, BeaconState, BlindedPayload, BlobSidecarList, Epoch, EthSpec, Hash256,
     SignedBeaconBlock, SignedBeaconBlockHeader, Slot,
 };
-use crate::eth1_finalization_cache::Eth1FinalizationData;
 
 #[derive(Debug, Clone, Derivative)]
 #[derivative(Hash(bound = "E: EthSpec"))]
@@ -44,7 +44,7 @@ impl<E: EthSpec> RpcBlock<E> {
         blobs: Option<BlobSidecarList<E>>,
     ) -> Result<Self, AvailabilityCheckError> {
         if let Some(blobs) = blobs.as_ref() {
-            data_availability_checker::consistency_checks( &block, blobs)?;
+            data_availability_checker::consistency_checks(&block, blobs)?;
         }
         let inner = match blobs {
             Some(blobs) => RpcBlockInner::BlockAndBlobs(block, blobs),
@@ -401,4 +401,4 @@ impl<E: EthSpec> AsBlock<E> for RpcBlock<E> {
     fn into_rpc_block(self) -> RpcBlock<E> {
         self
     }
-}
\ No newline at end of file
+}
diff --git a/beacon_node/beacon_chain/src/data_availability_checker.rs b/beacon_node/beacon_chain/src/data_availability_checker.rs
index eb33f64e911..d4c4d3c3d4a 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker.rs
@@ -317,7 +317,7 @@ pub fn make_available<T: EthSpec>(
 ) -> Result<AvailableBlock<T>, AvailabilityCheckError> {
     let blobs = VariableList::new(blobs.into_iter().map(|blob| blob.to_blob()).collect())?;
 
-    consistency_checks( &block, &blobs)?;
+    consistency_checks(&block, &blobs)?;
 
     Ok(AvailableBlock {
         block,
@@ -347,7 +347,10 @@ pub fn consistency_checks<T: EthSpec>(
         return Ok(());
     }
 
-    let block_root = blobs.first().map(|blob|blob.block_root).unwrap_or(block.canonical_root());
+    let block_root = blobs
+        .first()
+        .map(|blob| blob.block_root)
+        .unwrap_or(block.canonical_root());
     for (index, (block_commitment, blob)) in
         block_kzg_commitments.iter().zip(blobs.iter()).enumerate()
     {
diff --git a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
index 0b40df73a69..014fb4597bc 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs
@@ -540,8 +540,7 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
                             import_data,
                             payload_verification_outcome,
                         } = executed_block;
-                        let available_block =
-                            make_available(block, vec![])?;
+                        let available_block = make_available(block, vec![])?;
                         return Ok(Availability::Available(Box::new(
                             AvailableExecutedBlock::new(
                                 available_block,
@@ -591,8 +590,7 @@ impl<T: BeaconChainTypes> OverflowLRUCache<T> {
                  return Ok(Availability::MissingComponents(import_data.block_root))
             };
 
-            let available_block =
-                make_available(block, verified_blobs)?;
+            let available_block = make_available(block, verified_blobs)?;
             Ok(Availability::Available(Box::new(
                 AvailableExecutedBlock::new(
                     available_block,
diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
index b2cea41cb45..ae5f87fe83e 100644
--- a/beacon_node/beacon_chain/src/test_utils.rs
+++ b/beacon_node/beacon_chain/src/test_utils.rs
@@ -700,7 +700,7 @@ where
         let block = self.chain.get_blinded_block(block_root).unwrap().unwrap();
         let full_block = self.chain.store.make_full_block(block_root, block).unwrap();
         let blobs = self.chain.get_blobs(block_root).unwrap();
-        RpcBlock::new( Arc::new(full_block), blobs).unwrap()
+        RpcBlock::new(Arc::new(full_block), blobs).unwrap()
     }
 
     pub fn get_all_validators(&self) -> Vec<usize> {
@@ -1985,11 +1985,7 @@ where
             .process_block(
                 slot,
                 block.canonical_root(),
-                RpcBlock::new(
-                    Arc::new(block.clone()),
-                    blobs_without_signatures.clone(),
-                )
-                .unwrap(),
+                RpcBlock::new(Arc::new(block.clone()), blobs_without_signatures.clone()).unwrap(),
             )
             .await?;
         Ok((block_hash, (block, blobs), new_state))
diff --git a/beacon_node/beacon_chain/tests/attestation_production.rs b/beacon_node/beacon_chain/tests/attestation_production.rs
index db3ddf3bf09..907e7a40bb5 100644
--- a/beacon_node/beacon_chain/tests/attestation_production.rs
+++ b/beacon_node/beacon_chain/tests/attestation_production.rs
@@ -133,7 +133,8 @@ async fn produces_attestations() {
             assert_eq!(data.target.epoch, state.current_epoch(), "bad target epoch");
             assert_eq!(data.target.root, target_root, "bad target root");
 
-            let rpc_block = RpcBlock::<MainnetEthSpec>::new(Arc::new(block.clone()), blobs.clone()).unwrap();
+            let rpc_block =
+                RpcBlock::<MainnetEthSpec>::new(Arc::new(block.clone()), blobs.clone()).unwrap();
             let beacon_chain::data_availability_checker::MaybeAvailableBlock::Available(available_block) = chain
                 .data_availability_checker
                 .check_rpc_block_availability(rpc_block)
diff --git a/beacon_node/beacon_chain/tests/block_verification.rs b/beacon_node/beacon_chain/tests/block_verification.rs
index 852e40834c4..102707a3892 100644
--- a/beacon_node/beacon_chain/tests/block_verification.rs
+++ b/beacon_node/beacon_chain/tests/block_verification.rs
@@ -158,7 +158,9 @@ fn chain_segment_blocks(
     chain_segment
         .iter()
         .zip(blobs.into_iter())
-        .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
+        .map(|(snapshot, blobs)| {
+            RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()
+        })
         .collect()
 }
 
@@ -408,7 +410,9 @@ async fn assert_invalid_signature(
     let blocks: Vec<RpcBlock<E>> = snapshots
         .iter()
         .zip(chain_segment_blobs.iter())
-        .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
+        .map(|(snapshot, blobs)| {
+            RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()
+        })
         .collect();
 
     // Ensure the block will be rejected if imported in a chain segment.
@@ -433,7 +437,9 @@ async fn assert_invalid_signature(
         .iter()
         .take(block_index)
         .zip(chain_segment_blobs.iter())
-        .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
+        .map(|(snapshot, blobs)| {
+            RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()
+        })
         .collect();
     // We don't care if this fails, we just call this to ensure that all prior blocks have been
     // imported prior to this test.
@@ -450,7 +456,8 @@ async fn assert_invalid_signature(
             RpcBlock::new(
                 snapshots[block_index].beacon_block.clone(),
                 chain_segment_blobs[block_index].clone(),
-            ).unwrap(),
+            )
+            .unwrap(),
             NotifyExecutionLayer::Yes,
             || Ok(()),
         )
@@ -501,7 +508,9 @@ async fn invalid_signature_gossip_block() {
             .iter()
             .take(block_index)
             .zip(chain_segment_blobs.iter())
-            .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
+            .map(|(snapshot, blobs)| {
+                RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()
+            })
             .collect();
         harness
             .chain
@@ -546,7 +555,9 @@ async fn invalid_signature_block_proposal() {
         let blocks: Vec<RpcBlock<E>> = snapshots
             .iter()
             .zip(chain_segment_blobs.iter())
-            .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
+            .map(|(snapshot, blobs)| {
+                RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()
+            })
             .collect::<Vec<_>>();
         // Ensure the block will be rejected if imported in a chain segment.
         assert!(
@@ -757,7 +768,9 @@ async fn invalid_signature_deposit() {
         let blocks: Vec<RpcBlock<E>> = snapshots
             .iter()
             .zip(chain_segment_blobs.iter())
-            .map(|(snapshot, blobs)| RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap())
+            .map(|(snapshot, blobs)| {
+                RpcBlock::new(snapshot.beacon_block.clone(), blobs.clone()).unwrap()
+            })
             .collect();
         assert!(
             !matches!(
diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs
index 166417ba93c..1d2d62bc1fd 100644
--- a/beacon_node/network/src/network_beacon_processor/mod.rs
+++ b/beacon_node/network/src/network_beacon_processor/mod.rs
@@ -13,6 +13,7 @@ use beacon_processor::{
     MAX_SCHEDULED_WORK_QUEUE_LEN, MAX_WORK_EVENT_QUEUE_LEN,
 };
 use environment::null_logger;
+use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
 use lighthouse_network::{
     rpc::{BlocksByRangeRequest, BlocksByRootRequest, LightClientBootstrapRequest, StatusMessage},
     Client, MessageId, NetworkGlobals, PeerId, PeerRequestId,
@@ -26,7 +27,6 @@ use store::MemoryStore;
 use task_executor::test_utils::TestRuntime;
 use task_executor::TaskExecutor;
 use tokio::sync::mpsc::{self, error::TrySendError};
-use lighthouse_network::rpc::methods::{BlobsByRangeRequest, BlobsByRootRequest};
 use types::*;
 
 pub use sync_methods::ChainSegmentProcessId;
@@ -229,9 +229,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         })
     }
 
-    pub fn send_banana(){
-
-    }
+    pub fn send_banana() {}
 
     /// Create a new `Work` event for some sync committee signature.
     pub fn send_gossip_sync_signature(
@@ -563,12 +561,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     ) -> Result<(), Error<T::EthSpec>> {
         let processor = self.clone();
         let process_fn = move |send_idle_on_drop| {
-            processor.handle_blobs_by_range_request(
-                send_idle_on_drop,
-                peer_id,
-                request_id,
-                request,
-            )
+            processor.handle_blobs_by_range_request(send_idle_on_drop, peer_id, request_id, request)
         };
 
         self.try_send(BeaconWorkEvent {
@@ -586,12 +579,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
     ) -> Result<(), Error<T::EthSpec>> {
         let processor = self.clone();
         let process_fn = move |send_idle_on_drop| {
-            processor.handle_blobs_by_root_request(
-                send_idle_on_drop,
-                peer_id,
-                request_id,
-                request,
-            )
+            processor.handle_blobs_by_root_request(send_idle_on_drop, peer_id, request_id, request)
         };
 
         self.try_send(BeaconWorkEvent {
diff --git a/beacon_node/network/src/network_beacon_processor/sync_methods.rs b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
index 3a09373c56f..b21bc6abde8 100644
--- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
@@ -6,9 +6,9 @@ use crate::sync::{
     manager::{BlockProcessType, SyncMessage},
     ChainId,
 };
-use beacon_chain::data_availability_checker::MaybeAvailableBlock;
 use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
 use beacon_chain::data_availability_checker::AvailabilityCheckError;
+use beacon_chain::data_availability_checker::MaybeAvailableBlock;
 use beacon_chain::{
     observed_block_producers::Error as ObserveError, validator_monitor::get_block_delay_ms,
     AvailabilityProcessingStatus, BeaconChainError, BeaconChainTypes, BlockError,
@@ -270,7 +270,8 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         process_type: BlockProcessType,
     ) -> AsyncFn {
         let process_fn = async move {
-            self.clone().process_rpc_blobs(block_root, block, seen_timestamp, process_type)
+            self.clone()
+                .process_rpc_blobs(block_root, block, seen_timestamp, process_type)
                 .await;
         };
         Box::pin(process_fn)
@@ -306,7 +307,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         });
     }
 
-    pub fn send_delayed_lookup(&self, block_root: Hash256){
+    pub fn send_delayed_lookup(&self, block_root: Hash256) {
         self.send_sync_message(SyncMessage::MissingGossipBlockComponentsDelayed(block_root))
     }
 
diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs
index 39d3575d6e3..2c37d177aab 100644
--- a/beacon_node/network/src/network_beacon_processor/tests.rs
+++ b/beacon_node/network/src/network_beacon_processor/tests.rs
@@ -336,14 +336,16 @@ impl TestRig {
     }
 
     pub fn enqueue_blobs_by_range_request(&self, count: u64) {
-        self.network_beacon_processor.send_blobs_by_range_request(
-            PeerId::random(),
-            (ConnectionId::new(42), SubstreamId::new(24)),
-            BlobsByRangeRequest {
-                start_slot: 0,
-                count,
-            },
-        ).unwrap();
+        self.network_beacon_processor
+            .send_blobs_by_range_request(
+                PeerId::random(),
+                (ConnectionId::new(42), SubstreamId::new(24)),
+                BlobsByRangeRequest {
+                    start_slot: 0,
+                    count,
+                },
+            )
+            .unwrap();
     }
 
     pub fn enqueue_backfill_batch(&self) {
diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs
index 5a954d05a40..30a75a91052 100644
--- a/beacon_node/network/src/router.rs
+++ b/beacon_node/network/src/router.rs
@@ -209,18 +209,12 @@ impl<T: BeaconChainTypes> Router<T> {
                     .send_blocks_by_roots_request(peer_id, request_id, request),
             ),
             Request::BlobsByRange(request) => self.handle_beacon_processor_send_result(
-                self.network_beacon_processor.send_blobs_by_range_request(
-                    peer_id,
-                    request_id,
-                    request,
-                ),
+                self.network_beacon_processor
+                    .send_blobs_by_range_request(peer_id, request_id, request),
             ),
             Request::BlobsByRoot(request) => self.handle_beacon_processor_send_result(
-                self.network_beacon_processor.send_blobs_by_roots_request(
-                    peer_id,
-                    request_id,
-                    request,
-                ),
+                self.network_beacon_processor
+                    .send_blobs_by_roots_request(peer_id, request_id, request),
             ),
             Request::LightClientBootstrap(request) => self.handle_beacon_processor_send_result(
                 self.network_beacon_processor
@@ -311,7 +305,7 @@ impl<T: BeaconChainTypes> Router<T> {
                         blob_index,
                         signed_blob,
                         timestamp_now(),
-                    )
+                    ),
                 )
             }
             PubsubMessage::VoluntaryExit(exit) => {
diff --git a/beacon_node/network/src/service/tests.rs b/beacon_node/network/src/service/tests.rs
index 10110aa891b..544c5dd9c7f 100644
--- a/beacon_node/network/src/service/tests.rs
+++ b/beacon_node/network/src/service/tests.rs
@@ -3,6 +3,7 @@
 mod tests {
     use crate::persisted_dht::load_dht;
     use crate::{NetworkConfig, NetworkService};
+    use beacon_chain::test_utils::EphemeralHarnessType;
     use beacon_processor::{
         BeaconProcessorSend, MAX_SCHEDULED_WORK_QUEUE_LEN, MAX_WORK_EVENT_QUEUE_LEN,
     };
@@ -12,7 +13,6 @@ mod tests {
     use std::str::FromStr;
     use std::sync::Arc;
     use tokio::{runtime::Runtime, sync::mpsc};
-    use beacon_chain::test_utils::EphemeralHarnessType;
     use types::MinimalEthSpec as E;
 
     type BeaconChainHarness = beacon_chain::test_utils::BeaconChainHarness<EphemeralHarnessType<E>>;
diff --git a/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs b/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs
index c492470b4ae..55e9e49db30 100644
--- a/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/delayed_lookup.rs
@@ -1,12 +1,12 @@
+use crate::network_beacon_processor::NetworkBeaconProcessor;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use slog::{crit, };
+use slog::crit;
 use slot_clock::SlotClock;
 use std::sync::Arc;
 use tokio::sync::mpsc;
 use tokio::time::interval_at;
 use tokio::time::Instant;
-use types::{ Hash256};
-use crate::network_beacon_processor::NetworkBeaconProcessor;
+use types::Hash256;
 
 #[derive(Debug)]
 pub enum DelayedLookupMessage {
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index 37b5ee0e767..90829905b8a 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -313,13 +313,16 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS
                         downloaded_blobs,
                     } = components;
                     downloaded_block.as_ref().and_then(|block| {
-                                            //TODO(sean) figure out how to properly deal with a consistency error here,
-                                                // should we downscore the peer sending blobs?
-                                                let blobs = std::mem::take(downloaded_blobs);
-                                            let filtered=blobs.into_iter().filter_map(|b|b.clone()).collect::<Vec<_>>();
-                                            let blobs = VariableList::from(filtered);
-                                            RpcBlock::new(block.clone(), Some(blobs)).ok()
-                                        })
+                        //TODO(sean) figure out how to properly deal with a consistency error here,
+                        // should we downscore the peer sending blobs?
+                        let blobs = std::mem::take(downloaded_blobs);
+                        let filtered = blobs
+                            .into_iter()
+                            .filter_map(|b| b.clone())
+                            .collect::<Vec<_>>();
+                        let blobs = VariableList::from(filtered);
+                        RpcBlock::new(block.clone(), Some(blobs)).ok()
+                    })
                 } else {
                     None
                 }
diff --git a/beacon_node/network/src/sync/block_sidecar_coupling.rs b/beacon_node/network/src/sync/block_sidecar_coupling.rs
index b25dcdf334e..fce7a2e30d1 100644
--- a/beacon_node/network/src/sync/block_sidecar_coupling.rs
+++ b/beacon_node/network/src/sync/block_sidecar_coupling.rs
@@ -1,5 +1,5 @@
 use beacon_chain::block_verification_types::RpcBlock;
-use ssz_types::{VariableList};
+use ssz_types::VariableList;
 use std::{collections::VecDeque, sync::Arc};
 use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
 
diff --git a/beacon_node/network/src/sync/range_sync/range.rs b/beacon_node/network/src/sync/range_sync/range.rs
index f69a30b3ee0..277606e438c 100644
--- a/beacon_node/network/src/sync/range_sync/range.rs
+++ b/beacon_node/network/src/sync/range_sync/range.rs
@@ -387,18 +387,18 @@ mod tests {
     use beacon_chain::builder::Witness;
     use beacon_chain::eth1_chain::CachingEth1Backend;
     use beacon_chain::parking_lot::RwLock;
+    use beacon_chain::test_utils::{BeaconChainHarness, EphemeralHarnessType};
     use beacon_chain::EngineState;
     use beacon_processor::WorkEvent as BeaconWorkEvent;
     use lighthouse_network::rpc::BlocksByRangeRequest;
     use lighthouse_network::Request;
     use lighthouse_network::{rpc::StatusMessage, NetworkGlobals};
     use slog::{o, Drain};
-    use tokio::sync::mpsc;
-    use beacon_chain::test_utils::{BeaconChainHarness, EphemeralHarnessType};
-    use slot_clock::{TestingSlotClock, };
+    use slot_clock::TestingSlotClock;
     use std::collections::HashSet;
     use std::sync::Arc;
     use store::MemoryStore;
+    use tokio::sync::mpsc;
     use types::{Hash256, MinimalEthSpec as E};
 
     #[derive(Debug)]
diff --git a/consensus/fork_choice/tests/tests.rs b/consensus/fork_choice/tests/tests.rs
index bba7ccdbe67..b4981a3eea8 100644
--- a/consensus/fork_choice/tests/tests.rs
+++ b/consensus/fork_choice/tests/tests.rs
@@ -4,6 +4,7 @@ use std::fmt;
 use std::sync::Mutex;
 use std::time::Duration;
 
+use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::test_utils::{
     AttestationStrategy, BeaconChainHarness, BlockStrategy, EphemeralHarnessType,
 };
@@ -11,7 +12,6 @@ use beacon_chain::{
     BeaconChain, BeaconChainError, BeaconForkChoiceStore, ChainConfig, ForkChoiceError,
     StateSkipConfig, WhenSlotSkipped,
 };
-use beacon_chain::block_verification_types::RpcBlock;
 use fork_choice::{
     ForkChoiceStore, InvalidAttestation, InvalidBlock, PayloadVerificationStatus, QueuedAttestation,
 };
@@ -201,7 +201,11 @@ impl ForkChoiceTest {
             if !predicate(block.0.message(), &state) {
                 break;
             }
-            if let Ok(block_hash) = self.harness.process_block_result(RpcBlock::new(block.0, block.1).unwrap()).await {
+            if let Ok(block_hash) = self
+                .harness
+                .process_block_result(RpcBlock::new(block.0, block.1).unwrap())
+                .await
+            {
                 self.harness.attest_block(
                     &state,
                     block.0.state_root(),

From 8a6e8d51b6428efadf7bbaf8427fe7f2a228b0ac Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Tue, 25 Jul 2023 10:45:58 -0400
Subject: [PATCH 04/18] make block and blob single lookups generic

---
 beacon_node/network/src/router.rs             |   13 +-
 .../network/src/sync/block_lookups/mod.rs     | 1011 +++++------------
 .../src/sync/block_lookups/parent_lookup.rs   |  205 ++--
 .../sync/block_lookups/single_block_lookup.rs |  895 +++++++++------
 .../network/src/sync/block_lookups/tests.rs   |   20 +-
 beacon_node/network/src/sync/manager.rs       |  182 ++-
 .../network/src/sync/network_context.rs       |  173 ++-
 7 files changed, 1106 insertions(+), 1393 deletions(-)

diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs
index 30a75a91052..927229e7b7e 100644
--- a/beacon_node/network/src/router.rs
+++ b/beacon_node/network/src/router.rs
@@ -482,7 +482,10 @@ impl<T: BeaconChainTypes> Router<T> {
     ) {
         let request_id = match request_id {
             RequestId::Sync(sync_id) => match sync_id {
-                SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. } => {
+                SyncId::SingleBlock { .. }
+                | SyncId::SingleBlob { .. }
+                | SyncId::ParentLookup { .. }
+                | SyncId::ParentLookupBlob { .. } => {
                     unreachable!("Block lookups do not request BBRange requests")
                 }
                 id @ (SyncId::BackFillBlocks { .. }
@@ -550,6 +553,9 @@ impl<T: BeaconChainTypes> Router<T> {
                 | SyncId::BackFillBlockAndBlobs { .. } => {
                     unreachable!("Batch syncing do not request BBRoot requests")
                 }
+                SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. } => {
+                    unreachable!("Blob response to block by roots request")
+                }
             },
             RequestId::Router => unreachable!("All BBRoot requests belong to sync"),
         };
@@ -576,7 +582,10 @@ impl<T: BeaconChainTypes> Router<T> {
     ) {
         let request_id = match request_id {
             RequestId::Sync(sync_id) => match sync_id {
-                id @ (SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. }) => id,
+                id @ (SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. }) => id,
+                SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. } => {
+                    unreachable!("Block response to blobs by roots request")
+                }
                 SyncId::BackFillBlocks { .. }
                 | SyncId::RangeBlocks { .. }
                 | SyncId::RangeBlockAndBlobs { .. }
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index ff095c719ea..aef88bfc3e7 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -1,22 +1,24 @@
-use self::parent_lookup::PARENT_FAIL_TOLERANCE;
-use self::parent_lookup::{ParentLookup, ParentVerifyError};
-use self::single_block_lookup::{LookupVerifyError, SingleBlockLookup};
+use self::parent_lookup::ParentVerifyError;
+use self::single_block_lookup::SingleBlockLookup;
 use super::manager::BlockProcessingResult;
 use super::BatchProcessResult;
-use super::{
-    manager::{BlockProcessType, Id},
-    network_context::SyncNetworkContext,
-};
+use super::{manager::BlockProcessType, network_context::SyncNetworkContext};
 use crate::metrics;
 use crate::network_beacon_processor::ChainSegmentProcessId;
-use crate::sync::block_lookups::single_block_lookup::LookupId;
+use crate::sync::block_lookups::parent_lookup::ParentLookup;
+use crate::sync::block_lookups::single_block_lookup::LookupVerifyError;
+use crate::sync::manager::{Id, ResponseType};
 use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
 use beacon_chain::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
 use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
+use fnv::FnvHashMap;
 use lighthouse_network::rpc::RPCError;
 use lighthouse_network::{PeerAction, PeerId};
 use lru_cache::LRUTimeCache;
 pub use single_block_lookup::UnknownParentComponents;
+pub use single_block_lookup::{
+    BlobRequestState, BlockRequestState, Current, Lookup, Parent, RequestState,
+};
 use slog::{debug, error, trace, warn, Logger};
 use smallvec::SmallVec;
 use std::collections::HashMap;
@@ -26,7 +28,7 @@ use std::time::Duration;
 use store::{Hash256, SignedBeaconBlock};
 use strum::Display;
 use types::blob_sidecar::FixedBlobSidecarList;
-use types::{BlobSidecar, Slot};
+use types::{BlobSidecar, EthSpec, Slot};
 
 pub(crate) mod delayed_lookup;
 mod parent_lookup;
@@ -39,19 +41,18 @@ pub type RootBlockTuple<T> = (Hash256, Arc<SignedBeaconBlock<T>>);
 pub type RootBlobsTuple<T> = (Hash256, FixedBlobSidecarList<T>);
 
 const FAILED_CHAINS_CACHE_EXPIRY_SECONDS: u64 = 60;
-const SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS: u8 = 3;
+pub const SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS: u8 = 3;
 
-pub(crate) struct BlockLookups<T: BeaconChainTypes> {
+pub struct BlockLookups<T: BeaconChainTypes> {
     /// Parent chain lookups being downloaded.
     parent_lookups: SmallVec<[ParentLookup<T>; 3]>,
 
-    processing_parent_lookups:
-        HashMap<Hash256, (Vec<Hash256>, SingleBlockLookup<PARENT_FAIL_TOLERANCE, T>)>,
+    processing_parent_lookups: HashMap<Hash256, (Vec<Hash256>, SingleBlockLookup<Parent, T>)>,
 
     /// A cache of failed chain lookups to prevent duplicate searches.
     failed_chains: LRUTimeCache<Hash256>,
 
-    single_block_lookups: Vec<SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>>,
+    single_block_lookups: FnvHashMap<Id, SingleBlockLookup<Current, T>>,
 
     da_checker: Arc<DataAvailabilityChecker<T>>,
 
@@ -59,34 +60,6 @@ pub(crate) struct BlockLookups<T: BeaconChainTypes> {
     log: Logger,
 }
 
-pub type BlockRequestId = Id;
-pub type BlobRequestId = Id;
-
-#[derive(Debug, PartialEq)]
-enum StreamTerminator {
-    True,
-    False,
-}
-
-impl From<bool> for StreamTerminator {
-    fn from(value: bool) -> Self {
-        if value {
-            StreamTerminator::True
-        } else {
-            StreamTerminator::False
-        }
-    }
-}
-
-/// Used to track block or blob responses in places we want to reduce code duplication in
-/// response handling.
-// NOTE: a better solution may be to wrap request `Id` in an enum.
-#[derive(Debug, Copy, Clone)]
-pub enum ResponseType {
-    Block,
-    Blob,
-}
-
 /// This enum is used to track what a peer *should* be able to respond with respond based on
 /// other messages we've seen from this peer on the network. This is useful for peer scoring.
 /// We expect a peer tracked by the `BlockAndBlobs` variant to be able to respond to all
@@ -124,13 +97,6 @@ impl PeerShouldHave {
     }
 }
 
-/// Tracks the conditions under which we want to drop a parent or single block lookup.
-#[derive(Debug, Copy, Clone)]
-pub enum ShouldRemoveLookup {
-    True,
-    False,
-}
-
 impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn new(da_checker: Arc<DataAvailabilityChecker<T>>, log: Logger) -> Self {
         Self {
@@ -152,9 +118,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         &mut self,
         block_root: Hash256,
         peer_source: PeerShouldHave,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
-        let lookup = self.search_block_with(block_root, None, &[peer_source]);
+        let lookup = self.new_current_lookup(block_root, None, &[peer_source], cx);
         if let Some(lookup) = lookup {
             self.trigger_single_lookup(lookup, cx);
         }
@@ -163,8 +129,13 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     ///
     /// The request is not immediately triggered, and should be triggered by a call to
     /// `trigger_lookup_by_root`.
-    pub fn search_block_delayed(&mut self, block_root: Hash256, peer_source: PeerShouldHave) {
-        let lookup = self.search_block_with(block_root, None, &[peer_source]);
+    pub fn search_block_delayed(
+        &mut self,
+        block_root: Hash256,
+        peer_source: PeerShouldHave,
+        cx: &SyncNetworkContext<T>,
+    ) {
+        let lookup = self.new_current_lookup(block_root, None, &[peer_source], cx);
         if let Some(lookup) = lookup {
             self.add_single_lookup(lookup)
         }
@@ -181,9 +152,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block_root: Hash256,
         parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
-        let lookup = self.search_block_with(block_root, parent_components, peer_source);
+        let lookup = self.new_current_lookup(block_root, parent_components, peer_source, cx);
         if let Some(lookup) = lookup {
             self.trigger_single_lookup(lookup, cx);
         }
@@ -201,8 +172,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block_root: Hash256,
         parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
+        cx: &SyncNetworkContext<T>,
     ) {
-        let lookup = self.search_block_with(block_root, parent_components, peer_source);
+        let lookup = self.new_current_lookup(block_root, parent_components, peer_source, cx);
         if let Some(lookup) = lookup {
             self.add_single_lookup(lookup)
         }
@@ -211,8 +183,8 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     /// Attempts to trigger the request matching the given `block_root`.
     pub fn trigger_single_lookup(
         &mut self,
-        mut single_block_lookup: SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-        cx: &mut SyncNetworkContext<T>,
+        mut single_block_lookup: SingleBlockLookup<Current, T>,
+        cx: &SyncNetworkContext<T>,
     ) {
         if !single_block_lookup.triggered && single_block_lookup.request_block_and_blobs(cx).is_ok()
         {
@@ -221,11 +193,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         }
     }
 
-    pub fn add_single_lookup(
-        &mut self,
-        single_block_lookup: SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-    ) {
-        self.single_block_lookups.push(single_block_lookup);
+    pub fn add_single_lookup(&mut self, single_block_lookup: SingleBlockLookup<Current, T>) {
+        self.single_block_lookups
+            .insert(single_block_lookup.id, single_block_lookup);
 
         metrics::set_gauge(
             &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
@@ -236,12 +206,13 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn trigger_lookup_by_root(
         &mut self,
         block_root: Hash256,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) -> Result<(), ()> {
-        for lookup in self.single_block_lookups.iter_mut() {
+        for (_, lookup) in self.single_block_lookups.iter_mut() {
             if lookup.block_request_state.requested_block_root == block_root && !lookup.triggered {
-                lookup.request_block_and_blobs(cx)?;
-                lookup.triggered = true;
+                if lookup.request_block_and_blobs(cx).is_ok() {
+                    lookup.triggered = true;
+                }
             }
         }
         Ok(())
@@ -249,22 +220,23 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
 
     pub fn remove_lookup_by_root(&mut self, block_root: Hash256) {
         self.single_block_lookups
-            .retain(|lookup| lookup.block_request_state.requested_block_root != block_root);
+            .retain(|_id, lookup| lookup.block_request_state.requested_block_root != block_root);
     }
 
     /// Searches for a single block hash. If the blocks parent is unknown, a chain of blocks is
     /// constructed.
-    pub fn search_block_with(
+    pub fn new_current_lookup(
         &mut self,
         block_root: Hash256,
         parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
-    ) -> Option<SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>> {
+        cx: &SyncNetworkContext<T>,
+    ) -> Option<SingleBlockLookup<Current, T>> {
         // Do not re-request a block that is already being requested
-        if let Some(lookup) = self
+        if let Some((_, lookup)) = self
             .single_block_lookups
             .iter_mut()
-            .find(|lookup| lookup.is_for_block(block_root))
+            .find(|(id, lookup)| lookup.is_for_block(block_root))
         {
             lookup.add_peers(peers);
             if let Some(components) = parent_components {
@@ -304,6 +276,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             parent_components,
             peers,
             self.da_checker.clone(),
+            cx,
         ))
     }
 
@@ -315,7 +288,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block_root: Hash256,
         parent_root: Hash256,
         peer_id: PeerId,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
         // Gossip blocks or blobs shouldn't be propagated if parents are unavailable.
         let peer_source = PeerShouldHave::BlockAndBlobs(peer_id);
@@ -345,210 +318,131 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             // we are already processing this block, ignore it.
             return;
         }
-
-        let parent_lookup = ParentLookup::new(
+        let mut parent_lookup = ParentLookup::new(
             block_root,
             parent_root,
             peer_source,
             self.da_checker.clone(),
+            cx,
         );
-        self.request_parent_block_and_blobs(parent_lookup, cx);
+        if let Ok(()) = parent_lookup
+            .current_parent_request
+            .request_block_and_blobs(cx)
+        {
+            self.parent_lookups.push(parent_lookup);
+        }
     }
 
     /* Lookup responses */
 
-    pub fn single_block_lookup_response(
+    pub fn single_lookup_response<R: RequestState<Current, T>>(
         &mut self,
         id: Id,
         peer_id: PeerId,
-        block: Option<Arc<SignedBeaconBlock<T::EthSpec>>>,
+        response: Option<R::ResponseType>,
         seen_timestamp: Duration,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
-        let stream_terminator = block.is_none().into();
+        let is_stream_terminator = response.is_none();
+        let response_type = R::response_type();
         let log = self.log.clone();
 
-        let Some((has_pending_parent_request, request_ref)) = self.find_single_lookup_request(id, stream_terminator, ResponseType::Block) else {
-            return;
-        };
-
-        let should_remove = match request_ref.verify_block(block) {
-            Ok(Some((block_root, block))) => {
-                if let Some(parent_components) = request_ref.unknown_parent_components.as_mut() {
-                    parent_components.add_unknown_parent_block(block.clone());
-                };
-
-                if !has_pending_parent_request {
-                    let rpc_block = request_ref
-                        .get_downloaded_block()
-                        .unwrap_or(RpcBlock::new_without_blobs(block));
-                    // This is the correct block, send it for processing
-                    match self.send_block_for_processing(
-                        block_root,
-                        rpc_block,
-                        seen_timestamp,
-                        BlockProcessType::SingleBlock { id },
-                        cx,
-                    ) {
-                        Ok(()) => ShouldRemoveLookup::False,
-                        Err(()) => ShouldRemoveLookup::True,
-                    }
-                } else {
-                    ShouldRemoveLookup::False
-                }
+        let Some(lookup) = self.single_block_lookups.get_mut(&id) else {
+            if !is_stream_terminator {
+                warn!(
+                    self.log,
+                    "Block returned for single block lookup not present";
+                        "response_type" => ?response_type,
+                );
             }
-            Ok(None) => ShouldRemoveLookup::False,
-            Err(e) => handle_block_lookup_verify_error(
-                request_ref,
-                ResponseType::Block,
-                peer_id,
-                e,
-                cx,
-                &log,
-            ),
+            return;
         };
 
-        if matches!(should_remove, ShouldRemoveLookup::True) {
-            self.single_block_lookups
-                .retain(|req| req.id.block_request_id != Some(id));
-        }
-
-        metrics::set_gauge(
-            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
-            self.single_block_lookups.len() as i64,
-        );
-    }
+        let expected_block_root = lookup.block_request_state.requested_block_root;
 
-    pub fn single_blob_lookup_response(
-        &mut self,
-        id: Id,
-        peer_id: PeerId,
-        blob: Option<Arc<BlobSidecar<T::EthSpec>>>,
-        seen_timestamp: Duration,
-        cx: &mut SyncNetworkContext<T>,
-    ) {
-        let stream_terminator = blob.is_none().into();
+        let has_pending_parent_request = self
+            .parent_lookups
+            .iter()
+            .any(|parent_lookup| parent_lookup.chain_hash() == expected_block_root);
 
-        let log = self.log.clone();
+        let request_state = R::request_state_mut(lookup);
 
-        let Some((has_pending_parent_requests, request_ref)) =
-            self.find_single_lookup_request(id, stream_terminator, ResponseType::Blob) else {
-            return;
-        };
+        match request_state.verify_response(expected_block_root, response) {
+            Ok(Some((root, verified_response))) => {
+                if let Some(parent_components) = lookup.unknown_parent_components.as_mut() {
+                    R::add_to_parent_components(verified_response, parent_components);
 
-        let should_remove = match request_ref.verify_blob(blob) {
-            Ok(Some((block_root, blobs))) => {
-                if let Some(parent_components) = request_ref.unknown_parent_components.as_mut() {
-                    parent_components.add_unknown_parent_blobs(blobs);
-
-                    if !has_pending_parent_requests {
-                        request_ref
-                            .get_downloaded_block()
-                            .map(|block| {
-                                match self.send_block_for_processing(
-                                    block_root,
-                                    block,
-                                    seen_timestamp,
-                                    BlockProcessType::SingleBlock { id },
-                                    cx,
-                                ) {
-                                    Ok(()) => ShouldRemoveLookup::False,
-                                    Err(()) => ShouldRemoveLookup::True,
-                                }
-                            })
-                            .unwrap_or(ShouldRemoveLookup::False)
-                    } else {
-                        ShouldRemoveLookup::False
+                    if !has_pending_parent_request {
+                        if let Some(rpc_block) = lookup.get_downloaded_block() {
+                            if let Err(()) = self.send_block_for_processing(
+                                expected_block_root,
+                                rpc_block,
+                                seen_timestamp,
+                                BlockProcessType::SingleBlock { id },
+                                cx,
+                            ) {
+                                self.single_block_lookups.remove(&id);
+                            }
+                        }
                     }
                 } else {
-                    // These are the correct blobs, send them for processing
-                    match self.send_blobs_for_processing(
-                        block_root,
-                        blobs,
+                    if let Err(()) = R::send_for_processing(
+                        id,
+                        self,
+                        root,
+                        R::verified_to_reconstructed(verified_response),
                         seen_timestamp,
-                        BlockProcessType::SingleBlock { id },
-                        cx,
+                        &cx,
                     ) {
-                        Ok(()) => ShouldRemoveLookup::False,
-                        Err(()) => ShouldRemoveLookup::True,
+                        self.single_block_lookups.remove(&id);
                     }
                 }
             }
-            Ok(None) => ShouldRemoveLookup::False,
-            Err(e) => handle_block_lookup_verify_error(
-                request_ref,
-                ResponseType::Blob,
-                peer_id,
-                e,
-                cx,
-                &log,
-            ),
-        };
+            Ok(None) => {}
+            Err(e) => {
+                let msg = if matches!(e, LookupVerifyError::BenignFailure) {
+                    request_state
+                        .get_state_mut()
+                        .remove_peer_if_useless(&peer_id);
+                    "peer could not response to request"
+                } else {
+                    let msg = e.into();
+                    cx.report_peer(peer_id, PeerAction::LowToleranceError, msg);
+                    msg
+                };
 
-        if matches!(should_remove, ShouldRemoveLookup::True) {
-            self.single_block_lookups
-                .retain(|req| req.id.blob_request_id != Some(id));
+                debug!(log, "Single block lookup failed";
+                    "peer_id" => %peer_id,
+                    "error" => msg,
+                    "block_root" => ?expected_block_root,
+                    "response_type" => ?response_type
+                );
+                if let Err(()) = request_state.retry_request_after_failure(id, cx, &log) {
+                    self.single_block_lookups.remove(&id);
+                }
+            }
         }
 
+        //TODO(sean) move metric to trait to differentiate block and blob
         metrics::set_gauge(
             &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
             self.single_block_lookups.len() as i64,
         );
     }
 
-    /// Returns the lookup along with a `bool` representing whether the lookup has an outstanding
-    /// parent lookup that has yet to be resolved. This determines whether we send the
-    /// block or blob for processing because we would fail block processing and trigger a new lookup
-    /// via `UnknownParentBlock` or `UnknownParentBlob` until we process the parent.
-    fn find_single_lookup_request(
-        &mut self,
-        target_id: Id,
-        stream_terminator: StreamTerminator,
-        response_type: ResponseType,
-    ) -> Option<(
-        bool,
-        &mut SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-    )> {
-        let lookup = self.single_block_lookups.iter_mut().find_map(|req| {
-            let id_opt = match response_type {
-                ResponseType::Block => req.id.block_request_id,
-                ResponseType::Blob => req.id.blob_request_id,
-            };
-            if let Some(lookup_id) = id_opt {
-                if lookup_id == target_id {
-                    let has_pending_parent_request = self.parent_lookups.iter().any(|lookup| {
-                        lookup.chain_hash() == req.block_request_state.requested_block_root
-                    });
-
-                    return Some((has_pending_parent_request, req));
-                }
-            }
-            None
-        });
-
-        if lookup.is_none() && matches!(stream_terminator, StreamTerminator::False) {
-            warn!(
-                self.log,
-                "Block returned for single block lookup not present";
-                "response_type" => ?response_type,
-            );
-        }
-        lookup
-    }
-
     /// Process a response received from a parent lookup request.
-    pub fn parent_lookup_response(
+    pub fn parent_lookup_response<R: RequestState<Parent, T>>(
         &mut self,
         id: Id,
         peer_id: PeerId,
-        block: Option<Arc<SignedBeaconBlock<T::EthSpec>>>,
+        block: Option<R::ResponseType>,
         seen_timestamp: Duration,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
         let mut parent_lookup = if let Some(pos) = self
             .parent_lookups
             .iter()
-            .position(|request| request.pending_block_response(id))
+            .position(|request| request.current_parent_request.id == id)
         {
             self.parent_lookups.remove(pos)
         } else {
@@ -558,91 +452,18 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             return;
         };
 
-        match parent_lookup.verify_block(block, &mut self.failed_chains) {
-            Ok(Some((block_root, block))) => {
-                parent_lookup.add_current_request_block(block);
-                if let Some(rpc_block) = parent_lookup.current_parent_request.get_downloaded_block()
+        match parent_lookup.verify_block::<R>(block, &mut self.failed_chains) {
+            Ok(Some((block_root, verified_response))) => {
+                if let Some(parent_components) = parent_lookup
+                    .current_parent_request
+                    .unknown_parent_components
+                    .as_mut()
                 {
-                    let chain_hash = parent_lookup.chain_hash();
-                    if self
-                        .send_block_for_processing(
-                            block_root,
-                            rpc_block,
-                            seen_timestamp,
-                            BlockProcessType::ParentLookup { chain_hash },
-                            cx,
-                        )
-                        .is_ok()
-                    {
-                        self.parent_lookups.push(parent_lookup)
-                    }
-                } else {
-                    let outstanding_blobs_req = parent_lookup
-                        .current_parent_request
-                        .id
-                        .blob_request_id
-                        .is_some();
-                    if !outstanding_blobs_req {
-                        if let Ok(peer_id) = parent_lookup
-                            .current_parent_request
-                            .downloading_peer(ResponseType::Blob)
-                        {
-                            cx.report_peer(
-                                peer_id.to_peer_id(),
-                                PeerAction::MidToleranceError,
-                                "bbroot_failed_chains",
-                            );
-                        }
-
-                        self.request_parent_blobs(parent_lookup, cx);
-                    } else {
-                        self.parent_lookups.push(parent_lookup)
-                    }
+                    R::add_to_parent_components(verified_response, parent_components);
                 }
-            }
-            Ok(None) => {
-                // Request finished successfully, nothing else to do. It will be removed after the
-                // processing result arrives.
-                self.parent_lookups.push(parent_lookup);
-            }
-            Err(e) => {
-                self.handle_parent_verify_error(peer_id, parent_lookup, ResponseType::Block, e, cx)
-            }
-        };
-
-        metrics::set_gauge(
-            &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
-            self.parent_lookups.len() as i64,
-        );
-    }
-
-    pub fn parent_lookup_blob_response(
-        &mut self,
-        id: Id,
-        peer_id: PeerId,
-        blob: Option<Arc<BlobSidecar<T::EthSpec>>>,
-        seen_timestamp: Duration,
-        cx: &mut SyncNetworkContext<T>,
-    ) {
-        let mut parent_lookup = if let Some(pos) = self
-            .parent_lookups
-            .iter()
-            .position(|request| request.pending_blob_response(id))
-        {
-            self.parent_lookups.remove(pos)
-        } else {
-            if blob.is_some() {
-                debug!(self.log, "Response for a parent lookup blob request that was not found"; "peer_id" => %peer_id);
-            }
-            return;
-        };
-
-        match parent_lookup.verify_blob(blob, &mut self.failed_chains) {
-            Ok(Some((block_root, blobs))) => {
-                parent_lookup.add_current_request_blobs(blobs);
-                let chain_hash = parent_lookup.chain_hash();
                 if let Some(rpc_block) = parent_lookup.current_parent_request.get_downloaded_block()
                 {
+                    let chain_hash = parent_lookup.chain_hash();
                     if self
                         .send_block_for_processing(
                             block_root,
@@ -656,31 +477,32 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                         self.parent_lookups.push(parent_lookup)
                     }
                 } else {
+                    //TODO(sean) here, we could penalize a peer who previously sent us a blob list
+                    // that was incomplete, and trigger a re-request immediately
                     self.parent_lookups.push(parent_lookup)
                 }
             }
             Ok(None) => {
-                // Waiting for more blobs to arrive
+                // Request finished successfully, nothing else to do. It will be removed after the
+                // processing result arrives.
                 self.parent_lookups.push(parent_lookup);
             }
-            Err(e) => {
-                self.handle_parent_verify_error(peer_id, parent_lookup, ResponseType::Blob, e, cx)
-            }
+            Err(e) => self.handle_parent_verify_error::<R>(peer_id, parent_lookup, e, cx),
         };
 
+        //TODO(sean) move metric to trait to differentiate block and blob
         metrics::set_gauge(
             &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
             self.parent_lookups.len() as i64,
         );
     }
 
-    fn handle_parent_verify_error(
+    fn handle_parent_verify_error<R: RequestState<Parent, T>>(
         &mut self,
         peer_id: PeerId,
         mut parent_lookup: ParentLookup<T>,
-        response_type: ResponseType,
         e: ParentVerifyError,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
         match e {
             ParentVerifyError::RootMismatch
@@ -699,10 +521,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 cx.report_peer(peer_id, PeerAction::LowToleranceError, e);
 
                 // We try again if possible.
-                match response_type {
-                    ResponseType::Block => self.request_parent_block(parent_lookup, cx),
-                    ResponseType::Blob => self.request_parent_blobs(parent_lookup, cx),
-                };
+                self.request_parent(parent_lookup, cx)
             }
             ParentVerifyError::PreviousFailure { parent_root } => {
                 debug!(
@@ -724,13 +543,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     self.log,
                     "Requested peer could not respond to block request, requesting a new peer";
                 );
-                parent_lookup
-                    .current_parent_request
-                    .remove_peer_if_useless(&peer_id, response_type);
-                match response_type {
-                    ResponseType::Block => self.request_parent_block(parent_lookup, cx),
-                    ResponseType::Blob => self.request_parent_blobs(parent_lookup, cx),
-                };
+                let request_state = R::request_state_mut(&mut parent_lookup.current_parent_request);
+                request_state.remove_if_useless(&peer_id);
+                self.request_parent(parent_lookup, cx)
             }
         }
     }
@@ -738,14 +553,12 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     /* Error responses */
 
     pub fn peer_disconnected(&mut self, peer_id: &PeerId, cx: &mut SyncNetworkContext<T>) {
-        self.single_block_lookups.retain_mut(|req| {
-            let should_remove_block =
-                should_remove_disconnected_peer(ResponseType::Block, peer_id, cx, req, &self.log);
-            let should_remove_blob =
-                should_remove_disconnected_peer(ResponseType::Blob, peer_id, cx, req, &self.log);
-
-            matches!(should_remove_block, ShouldRemoveLookup::False)
-                && matches!(should_remove_blob, ShouldRemoveLookup::False)
+        /* Check disconnection for single lookups */
+        self.single_block_lookups.retain(|id, req| {
+            let should_remove_lookup =
+                req.should_remove_disconnected_peer(*id, peer_id, cx, &self.log);
+
+            !should_remove_lookup
         });
 
         /* Check disconnection for parent lookups */
@@ -755,83 +568,60 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         }) {
             let parent_lookup = self.parent_lookups.remove(pos);
             trace!(self.log, "Parent lookup's peer disconnected"; &parent_lookup);
-            self.request_parent_block_and_blobs(parent_lookup, cx);
+            self.request_parent(parent_lookup, cx);
         }
     }
 
     /// An RPC error has occurred during a parent lookup. This function handles this case.
-    pub fn parent_lookup_failed(
+    pub fn parent_lookup_failed<R: RequestState<Parent, T>>(
         &mut self,
         id: Id,
         peer_id: PeerId,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
         error: RPCError,
     ) {
         let msg = error.as_static_str();
         if let Some(pos) = self
             .parent_lookups
             .iter()
-            .position(|request| request.pending_block_response(id))
+            .position(|request| request.current_parent_request.id == id)
         {
             let mut parent_lookup = self.parent_lookups.remove(pos);
-            parent_lookup.block_download_failed();
+            R::request_state_mut(&mut parent_lookup.current_parent_request)
+                .register_failure_downloading();
             trace!(self.log, "Parent lookup block request failed"; &parent_lookup, "error" => msg);
 
-            self.request_parent_block(parent_lookup, cx);
+            self.request_parent(parent_lookup, cx);
         } else {
             return debug!(self.log, "RPC failure for a block parent lookup request that was not found"; "peer_id" => %peer_id, "error" => msg);
         };
 
-        if let Some(pos) = self
-            .parent_lookups
-            .iter()
-            .position(|request| request.pending_blob_response(id))
-        {
-            let mut parent_lookup = self.parent_lookups.remove(pos);
-            parent_lookup.blob_download_failed();
-            trace!(self.log, "Parent lookup blobs request failed"; &parent_lookup, "error" => msg);
-
-            self.request_parent_blobs(parent_lookup, cx);
-        } else {
-            return debug!(self.log, "RPC failure for a blobs parent lookup request that was not found"; "peer_id" => %peer_id, "error" => msg);
-        };
         metrics::set_gauge(
             &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
             self.parent_lookups.len() as i64,
         );
     }
 
-    pub fn single_block_lookup_failed(
+    pub fn single_block_lookup_failed<R: RequestState<Current, T>>(
         &mut self,
         id: Id,
         peer_id: &PeerId,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
         error: RPCError,
     ) {
         let msg = error.as_static_str();
-        self.single_block_lookups.retain_mut(|req| {
-            let should_remove_block = should_remove_failed_lookup(
-                id,
-                ResponseType::Block,
-                msg,
-                peer_id,
-                cx,
-                req,
-                &self.log,
-            );
-            let should_remove_blob = should_remove_failed_lookup(
-                id,
-                ResponseType::Blob,
-                msg,
-                peer_id,
-                cx,
-                req,
-                &self.log,
-            );
-
-            matches!(should_remove_block, ShouldRemoveLookup::False)
-                && matches!(should_remove_blob, ShouldRemoveLookup::False)
-        });
+        let Some(lookup) = self.single_block_lookups.get_mut(&id) else {
+            debug!(self.log, "Error response to dropped lookup"; "error" => ?error);
+            return;
+        };
+        let root = lookup.block_request_state.requested_block_root;
+        let request_state = R::request_state_mut(lookup);
+        request_state.register_failure_downloading();
+        let response_type = R::response_type();
+        trace!(self.log, "Single lookup failed"; "block_root" => ?root, "error" => msg, "response_type" => ?response_type);
+        if let Err(()) = request_state.retry_request_after_failure(id, cx, &self.log) {
+            self.single_block_lookups.remove(&id);
+        };
 
         metrics::set_gauge(
             &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
@@ -841,48 +631,71 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
 
     /* Processing responses */
 
-    pub fn single_block_component_processed(
+    pub fn single_block_component_processed<R: RequestState<Current, T>>(
         &mut self,
         target_id: Id,
         result: BlockProcessingResult<T::EthSpec>,
-        response_type: ResponseType,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
-        let lookup_components_opt =
-            self.single_block_lookups
-                .iter_mut()
-                .enumerate()
-                .find_map(|(index, req)| {
-                    let block_match = req.id.block_request_id.as_ref() == Some(&target_id);
-                    let blob_match = req.id.blob_request_id.as_ref() == Some(&target_id);
-                    (block_match || blob_match).then_some((index, req))
-                });
-        let (index, request_ref) = match lookup_components_opt {
-            Some(req) => req,
-            None => {
-                return debug!(
-                    self.log,
-                    "Block component processed for single block lookup not present"
-                );
-            }
-        };
+        let Some(request_ref) = self.single_block_lookups.get_mut(&target_id) else {
+           debug!(self.log, "Block component processed for single block lookup not present"    );
+           return;
+       };
 
         let root = request_ref.block_request_state.requested_block_root;
-        let peer_id = request_ref.processing_peer(response_type);
+        let request_state = R::request_state_mut(request_ref);
+        let peer_id = request_state.get_state().processing_peer();
+        request_state.get_state_mut().component_processed = true;
 
         let peer_id = match peer_id {
             Ok(peer) => peer,
             Err(_) => return,
         };
 
-        let should_remove_lookup = match result {
+        match result {
             BlockProcessingResult::Ok(status) => match status {
                 AvailabilityProcessingStatus::Imported(root) => {
                     trace!(self.log, "Single block processing succeeded"; "block" => %root);
-                    ShouldRemoveLookup::True
+                    self.single_block_lookups.remove(&target_id);
                 }
                 AvailabilityProcessingStatus::MissingComponents(_, _block_root) => {
-                    should_remove_missing_components(request_ref, response_type, cx, &self.log)
+                    // if this was the result of a blocks request, the block peer did nothing wrong.
+                    // if we already had a blobs resposne, we should penalize the blobs peer because
+                    // they did not provide all blobs.
+                    if request_ref.both_components_processed() {
+                        if let Ok(blob_peer) =
+                            request_ref.blob_request_state.state.processing_peer()
+                        {
+                            if let PeerShouldHave::BlockAndBlobs(blob_peer) = blob_peer {
+                                cx.report_peer(
+                                    blob_peer,
+                                    PeerAction::MidToleranceError,
+                                    "single_block_failure",
+                                );
+                            }
+                            request_ref
+                                .blob_request_state
+                                .state
+                                .remove_peer_if_useless(blob_peer.as_peer_id());
+                            if !<BlobRequestState<
+                                single_block_lookup::Current,
+                                <T as BeaconChainTypes>::EthSpec,
+                            > as RequestState<single_block_lookup::Current, T>>::downloading(
+                                &request_ref.blob_request_state,
+                            ) {
+                                // Try it again if possible.
+                                if let Err(()) = request_ref
+                                    .blob_request_state
+                                    .retry_request_after_failure(target_id, cx, &self.log)
+                                {
+                                    self.single_block_lookups.remove(&target_id);
+                                };
+                            }
+                        } else {
+                            trace!(self.log, "Dropped blob peer prior to penalizing"; "root" => ?root);
+                            self.single_block_lookups.remove(&target_id);
+                        };
+                    }
                 }
             },
             BlockProcessingResult::Ignored => {
@@ -893,26 +706,25 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     "Single block processing was ignored, cpu might be overloaded";
                     "action" => "dropping single block request"
                 );
-                ShouldRemoveLookup::True
+                self.single_block_lookups.remove(&target_id);
             }
             BlockProcessingResult::Err(e) => {
                 trace!(self.log, "Single block processing failed"; "block" => %root, "error" => %e);
                 match e {
                     BlockError::BlockIsAlreadyKnown => {
                         // No error here
-                        ShouldRemoveLookup::True
+                        self.single_block_lookups.remove(&target_id);
                     }
                     BlockError::BeaconChainError(e) => {
                         // Internal error
                         error!(self.log, "Beacon chain error processing single block"; "block_root" => %root, "error" => ?e);
-                        ShouldRemoveLookup::True
+                        self.single_block_lookups.remove(&target_id);
                     }
                     BlockError::ParentUnknown(block) => {
                         let slot = block.slot();
                         let parent_root = block.parent_root();
                         request_ref.add_unknown_parent_components(block.into());
                         self.search_parent(slot, root, parent_root, peer_id.to_peer_id(), cx);
-                        ShouldRemoveLookup::False
                     }
                     ref e @ BlockError::ExecutionPayloadError(ref epe) if !epe.penalize_peer() => {
                         // These errors indicate that the execution layer is offline
@@ -923,7 +735,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                             "root" => %root,
                             "error" => ?e
                         );
-                        ShouldRemoveLookup::True
+                        self.single_block_lookups.remove(&target_id);
                     }
                     BlockError::AvailabilityCheck(
                         AvailabilityCheckError::KzgVerificationFailed,
@@ -931,27 +743,28 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     | BlockError::AvailabilityCheck(AvailabilityCheckError::Kzg(_))
                     | BlockError::BlobValidation(_) => {
                         warn!(self.log, "Blob validation failure"; "root" => %root, "peer_id" => %peer_id);
-                        if let Ok(blob_peer) = request_ref.processing_peer(ResponseType::Blob) {
+                        if let Ok(blob_peer) =
+                            request_ref.blob_request_state.state.processing_peer()
+                        {
                             cx.report_peer(
                                 blob_peer.to_peer_id(),
                                 PeerAction::MidToleranceError,
                                 "single_blob_failure",
                             );
                             // Try it again if possible.
-                            retry_request_after_failure(
-                                request_ref,
-                                ResponseType::Blob,
-                                peer_id.as_peer_id(),
-                                cx,
-                                &self.log,
-                            )
-                        } else {
-                            ShouldRemoveLookup::False
+                            if let Err(()) = request_ref
+                                .blob_request_state
+                                .retry_request_after_failure(target_id, cx, &self.log)
+                            {
+                                self.single_block_lookups.remove(&target_id);
+                            };
                         }
                     }
                     other => {
                         warn!(self.log, "Peer sent invalid block in single block lookup"; "root" => %root, "error" => ?other, "peer_id" => %peer_id);
-                        if let Ok(block_peer) = request_ref.processing_peer(ResponseType::Block) {
+                        if let Ok(block_peer) =
+                            request_ref.block_request_state.state.processing_peer()
+                        {
                             cx.report_peer(
                                 block_peer.to_peer_id(),
                                 PeerAction::MidToleranceError,
@@ -959,25 +772,19 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                             );
 
                             // Try it again if possible.
-                            retry_request_after_failure(
-                                request_ref,
-                                ResponseType::Block,
-                                block_peer.as_peer_id(),
-                                cx,
-                                &self.log,
-                            )
-                        } else {
-                            ShouldRemoveLookup::False
+                            if let Err(()) = request_ref
+                                .blob_request_state
+                                .retry_request_after_failure(target_id, cx, &self.log)
+                            {
+                                self.single_block_lookups.remove(&target_id);
+                            };
                         }
                     }
                 }
             }
         };
 
-        if matches!(should_remove_lookup, ShouldRemoveLookup::True) {
-            self.single_block_lookups.remove(index);
-        }
-
+        //TODO(sean) move metrics to lookup response trait
         metrics::set_gauge(
             &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
             self.single_block_lookups.len() as i64,
@@ -989,7 +796,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         chain_hash: Hash256,
         result: BlockProcessingResult<T::EthSpec>,
         response_type: ResponseType,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
         let index = self
             .parent_lookups
@@ -1002,13 +809,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             return debug!(self.log, "Process response for a parent lookup request that was not found"; "chain_hash" => %chain_hash);
         };
 
-        let peer_id = parent_lookup
-            .current_parent_request
-            .processing_peer(response_type);
-
-        let peer_id = match peer_id {
-            Ok(peer) => peer,
-            Err(_) => return,
+        let Ok(peer_id) =
+            parent_lookup.processing_peer() else {
+            return
         };
 
         match &result {
@@ -1042,7 +845,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             }
             BlockProcessingResult::Err(BlockError::ParentUnknown(block)) => {
                 parent_lookup.add_unknown_parent_block(block);
-                self.request_parent_block_and_blobs(parent_lookup, cx);
+                self.request_parent(parent_lookup, cx);
             }
             BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(_))
             | BlockProcessingResult::Err(BlockError::BlockIsAlreadyKnown { .. }) => {
@@ -1059,15 +862,27 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 };
                 let (chain_hash, mut blocks, hashes, block_request) =
                     parent_lookup.parts_for_processing();
-                if let Some(child_block) = self.single_block_lookups.iter_mut().find_map(|req| {
-                    if req.block_request_state.requested_block_root == chain_hash {
-                        req.get_downloaded_block()
+
+                // Find the child block that spawned the parent lookup request and add it to the chain
+                // to send for processing.
+                if let Some(child_lookup_id) =
+                    self.single_block_lookups.iter().find_map(|(id, lookup)| {
+                        (lookup.block_request_state.requested_block_root == chain_hash).then(|| *id)
+                    })
+                {
+                    let Some(child_lookup) = self.single_block_lookups.get_mut(&child_lookup_id)  else {
+                        debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
+                        return;
+                    };
+                    if let Some(rpc_block) = child_lookup.get_downloaded_block() {
+                        blocks.push(rpc_block);
                     } else {
-                        None
+                        trace!(self.log, "Parent lookup chain complete, awaiting child response"; "chain_hash" => ?chain_hash);
                     }
-                }) {
-                    blocks.push(child_block);
+                } else {
+                    debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
                 };
+
                 let process_id = ChainSegmentProcessId::ParentLookup(chain_hash);
 
                 match beacon_processor.send_chain_segment(process_id, blocks) {
@@ -1120,7 +935,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         &mut self,
         outcome: BlockError<<T as BeaconChainTypes>::EthSpec>,
         peer_id: PeerId,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
         mut parent_lookup: ParentLookup<T>,
     ) {
         // all else we consider the chain a failure and downvote the peer that sent
@@ -1135,16 +950,15 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         // ambiguity.
         cx.report_peer(peer_id, PeerAction::MidToleranceError, "parent_request_err");
         // Try again if possible
-        parent_lookup.block_processing_failed();
-        parent_lookup.blob_processing_failed();
-        self.request_parent_block_and_blobs(parent_lookup, cx);
+        parent_lookup.processing_failed();
+        self.request_parent(parent_lookup, cx);
     }
 
     pub fn parent_chain_processed(
         &mut self,
         chain_hash: Hash256,
         result: BatchProcessResult,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) {
         let request = match self.processing_parent_lookups.remove(&chain_hash) {
             Some((_hashes, request)) => request,
@@ -1156,42 +970,36 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         debug!(self.log, "Parent chain processed"; "chain_hash" => %chain_hash, "result" => ?result);
         match result {
             BatchProcessResult::Success { .. } => {
-                if let Some((index, _)) = self
+                let Some(id) = self
                     .single_block_lookups
                     .iter()
-                    .enumerate()
-                    .find(|(_, req)| req.block_request_state.requested_block_root == chain_hash)
-                {
-                    if let Some((lookup_id, rpc_block)) =
-                        self.single_block_lookups.get_mut(index).and_then(|lookup| {
-                            lookup
-                                .get_downloaded_block()
-                                .map(|block| (lookup.id.clone(), block))
-                        })
-                    {
-                        let LookupId {
-                            block_request_id,
-                            blob_request_id,
-                        } = lookup_id;
-                        let Some(id) = block_request_id.or(blob_request_id) else {
-                                warn!(self.log, "No id found for single block lookup"; "chain_hash" => %chain_hash);
-                                return;
-                            };
+                    .find_map(|(id, req)|
+                        (req.block_request_state.requested_block_root == chain_hash).then(|| *id)) else {
+                    warn!(self.log, "No id found for single block lookup"; "chain_hash" => %chain_hash);
+                    return;
+                };
 
-                        // This is the correct block, send it for processing
-                        if self
-                            .send_block_for_processing(
-                                chain_hash,
-                                rpc_block,
-                                Duration::from_secs(0), //TODO(sean) pipe this through
-                                BlockProcessType::SingleBlock { id },
-                                cx,
-                            )
-                            .is_err()
-                        {
-                            // Remove to avoid inconsistencies
-                            self.single_block_lookups.remove(index);
-                        }
+                let Some(lookup) = self
+                    .single_block_lookups
+                    .get_mut(&id) else {
+                    warn!(self.log, "No id found for single block lookup"; "chain_hash" => %chain_hash);
+                    return;
+                };
+
+                if let Some(rpc_block) = lookup.get_downloaded_block() {
+                    // This is the correct block, send it for processing
+                    if self
+                        .send_block_for_processing(
+                            chain_hash,
+                            rpc_block,
+                            Duration::from_secs(0), //TODO(sean) pipe this through
+                            BlockProcessType::SingleBlock { id: id },
+                            cx,
+                        )
+                        .is_err()
+                    {
+                        // Remove to avoid inconsistencies
+                        self.single_block_lookups.remove(&id);
                     }
                 }
             }
@@ -1225,7 +1033,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block: RpcBlock<T::EthSpec>,
         duration: Duration,
         process_type: BlockProcessType,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) -> Result<(), ()> {
         match cx.beacon_processor_if_enabled() {
             Some(beacon_processor) => {
@@ -1259,7 +1067,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         blobs: FixedBlobSidecarList<T::EthSpec>,
         duration: Duration,
         process_type: BlockProcessType,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
     ) -> Result<(), ()> {
         let blob_count = blobs.iter().filter(|b| b.is_some()).count();
         if blob_count == 0 {
@@ -1288,49 +1096,10 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         }
     }
 
-    fn request_parent_block(
-        &mut self,
-        mut parent_lookup: ParentLookup<T>,
-        cx: &mut SyncNetworkContext<T>,
-    ) {
-        let response = parent_lookup.request_parent_block(cx);
-        self.handle_response(parent_lookup, cx, response, ResponseType::Block);
-    }
-
-    fn request_parent_blobs(
-        &mut self,
-        mut parent_lookup: ParentLookup<T>,
-        cx: &mut SyncNetworkContext<T>,
-    ) {
-        let response = parent_lookup.request_parent_blobs(cx);
-        self.handle_response(parent_lookup, cx, response, ResponseType::Blob);
-    }
-
-    fn request_parent_block_and_blobs(
-        &mut self,
-        mut parent_lookup: ParentLookup<T>,
-        cx: &mut SyncNetworkContext<T>,
-    ) {
-        let block_res = parent_lookup.request_parent_block(cx);
-        match block_res {
-            Ok(()) => {
-                let blob_res = parent_lookup.request_parent_blobs(cx);
-                self.handle_response(parent_lookup, cx, blob_res, ResponseType::Blob)
-            }
-            Err(e) => {
-                self.handle_response(parent_lookup, cx, Err(e), ResponseType::Block);
-            }
-        }
-    }
+    fn request_parent(&mut self, mut parent_lookup: ParentLookup<T>, cx: &SyncNetworkContext<T>) {
+        let response = parent_lookup.request_parent(cx);
 
-    fn handle_response(
-        &mut self,
-        parent_lookup: ParentLookup<T>,
-        cx: &mut SyncNetworkContext<T>,
-        result: Result<(), parent_lookup::RequestError>,
-        response_type: ResponseType,
-    ) {
-        match result {
+        match response {
             Err(e) => {
                 debug!(self.log, "Failed to request parent"; &parent_lookup, "error" => e.as_static());
                 match e {
@@ -1340,7 +1109,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     parent_lookup::RequestError::ChainTooLong => {
                         self.failed_chains.insert(parent_lookup.chain_hash());
                         // This indicates faulty peers.
-                        for &peer_id in parent_lookup.used_peers(response_type) {
+                        for &peer_id in parent_lookup.used_peers() {
                             cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
                         }
                     }
@@ -1353,7 +1122,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                             self.failed_chains.insert(parent_lookup.chain_hash());
                         }
                         // This indicates faulty peers.
-                        for &peer_id in parent_lookup.used_peers(response_type) {
+                        for &peer_id in parent_lookup.used_peers() {
                             cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
                         }
                     }
@@ -1361,6 +1130,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                         // This happens if the peer disconnects while the block is being
                         // processed. Drop the request without extra penalty
                     }
+                    parent_lookup::RequestError::AlreadyDownloaded => {}
                 }
             }
             Ok(_) => {
@@ -1389,175 +1159,8 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     }
 }
 
-fn handle_block_lookup_verify_error<T: BeaconChainTypes>(
-    request_ref: &mut SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-    response_type: ResponseType,
-    peer_id: PeerId,
-    e: LookupVerifyError,
-    cx: &mut SyncNetworkContext<T>,
-    log: &Logger,
-) -> ShouldRemoveLookup {
-    let msg = if matches!(e, LookupVerifyError::BenignFailure) {
-        request_ref.remove_peer_if_useless(&peer_id, response_type);
-        "peer could not response to request"
-    } else {
-        let msg = e.into();
-        cx.report_peer(peer_id, PeerAction::LowToleranceError, msg);
-        msg
-    };
-
-    debug!(log, "Single block lookup failed";
-        "peer_id" => %peer_id,
-        "error" => msg,
-        "block_root" => ?request_ref.block_request_state.requested_block_root,
-        "response_type" => ?response_type
-    );
-    retry_request_after_failure(request_ref, response_type, &peer_id, cx, log)
-}
-
-fn retry_request_after_failure<T: BeaconChainTypes>(
-    request_ref: &mut SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-    response_type: ResponseType,
-    initial_peer_id: &PeerId,
-    cx: &mut SyncNetworkContext<T>,
-    log: &Logger,
-) -> ShouldRemoveLookup {
-    let requested_block_root = request_ref.block_request_state.requested_block_root;
-
-    // try the request again if possible
-    match response_type {
-        ResponseType::Block => {
-            let id = request_ref.request_block().map(|request_opt| {
-                request_opt
-                    .map(|(peer_id, request)| cx.single_block_lookup_request(peer_id, request))
-            });
-            match id {
-                Ok(Some(Ok(id))) => {
-                    request_ref.id.block_request_id = Some(id);
-                }
-                Ok(Some(Err(e))) => {
-                    debug!(log, "Single block lookup failed";
-                    "peer_id" => %initial_peer_id,
-                    "error" => ?e,
-                    "block_root" => ?requested_block_root,
-                    "response_type" => ?response_type);
-                    return ShouldRemoveLookup::True;
-                }
-                Ok(None) => {
-                    request_ref.id.block_request_id = None;
-                    // The lookup failed but the block or blob was found via other means.
-                }
-                Err(e) => {
-                    debug!(log, "Single block lookup failed";
-                    "peer_id" => %initial_peer_id,
-                    "error" => ?e,
-                    "block_root" => ?requested_block_root,
-                    "response_type" => ?response_type);
-                    return ShouldRemoveLookup::True;
-                }
-            }
-        }
-        ResponseType::Blob => {
-            let id = request_ref.request_blobs().map(|request_opt| {
-                request_opt
-                    .map(|(peer_id, request)| cx.single_blobs_lookup_request(peer_id, request))
-            });
-
-            match id {
-                Ok(Some(Ok(id))) => {
-                    request_ref.id.blob_request_id = Some(id);
-                }
-                Ok(Some(Err(e))) => {
-                    debug!(log, "Single block lookup failed";
-                    "peer_id" => %initial_peer_id,
-                    "error" => ?e,
-                    "block_root" => ?requested_block_root,
-                    "response_type" => ?response_type);
-                    return ShouldRemoveLookup::True;
-                }
-                Ok(None) => {
-                    request_ref.id.blob_request_id = None;
-                    // The lookup failed but the block or blob was found via other means.
-                }
-                Err(e) => {
-                    debug!(log, "Single block lookup failed";
-                    "peer_id" => %initial_peer_id,
-                    "error" => ?e,
-                    "block_root" => ?requested_block_root,
-                    "response_type" => ?response_type);
-                    return ShouldRemoveLookup::True;
-                }
-            }
-        }
-    };
-    ShouldRemoveLookup::False
-}
-
-fn should_remove_disconnected_peer<T: BeaconChainTypes>(
-    response_type: ResponseType,
-    peer_id: &PeerId,
-    cx: &mut SyncNetworkContext<T>,
-    req: &mut SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-    log: &Logger,
-) -> ShouldRemoveLookup {
-    if req.check_peer_disconnected(peer_id, response_type).is_err() {
-        trace!(log, "Single lookup failed on peer disconnection"; "block_root" => ?req.block_request_state.requested_block_root, "response_type" => ?response_type);
-        retry_request_after_failure(req, response_type, peer_id, cx, log)
-    } else {
-        ShouldRemoveLookup::False
-    }
-}
-
-fn should_remove_failed_lookup<T: BeaconChainTypes>(
-    id: Id,
-    response_type: ResponseType,
-    msg: &'static str,
-    peer_id: &PeerId,
-    cx: &mut SyncNetworkContext<T>,
-    req: &mut SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-    log: &Logger,
-) -> ShouldRemoveLookup {
-    if req.id.block_request_id == Some(id) || req.id.blob_request_id == Some(id) {
-        req.register_failure_downloading(response_type);
-        trace!(log, "Single lookup failed"; "block" => %req.block_request_state.requested_block_root, "error" => msg, "response_type" => ?response_type);
-        retry_request_after_failure(req, response_type, peer_id, cx, log)
-    } else {
-        ShouldRemoveLookup::False
-    }
-}
-
-fn should_remove_missing_components<T: BeaconChainTypes>(
-    request_ref: &mut SingleBlockLookup<SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS, T>,
-    response_type: ResponseType,
-    cx: &mut SyncNetworkContext<T>,
-    log: &Logger,
-) -> ShouldRemoveLookup {
-    request_ref.set_component_processed(response_type);
-
-    // If we get a missing component response after processing both a blob and a block response, the
-    // blobs must be what are missing.
-    if request_ref.both_components_processed() {
-        let Ok(blob_peer) = request_ref.processing_peer(ResponseType::Blob) else {
-            return ShouldRemoveLookup::False;
-        };
-        if let PeerShouldHave::BlockAndBlobs(blob_peer) = blob_peer {
-            cx.report_peer(
-                blob_peer,
-                PeerAction::MidToleranceError,
-                "single_block_failure",
-            );
-        }
-        request_ref.remove_peer_if_useless(blob_peer.as_peer_id(), ResponseType::Blob);
-        if !request_ref.downloading(ResponseType::Blob) {
-            // Try it again if possible.
-            return retry_request_after_failure(
-                request_ref,
-                ResponseType::Blob,
-                blob_peer.as_peer_id(),
-                cx,
-                log,
-            );
-        }
-    }
-    ShouldRemoveLookup::False
+#[derive(Debug, Copy, Clone)]
+pub enum LookupType {
+    Current,
+    Parent,
 }
diff --git a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
index 6d870b5aba3..1df51bf7f06 100644
--- a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
@@ -1,18 +1,21 @@
 use super::single_block_lookup::{LookupRequestError, LookupVerifyError, SingleBlockLookup};
-use super::{BlobRequestId, BlockRequestId, DownloadedBlocks, PeerShouldHave, ResponseType};
-use crate::sync::block_lookups::single_block_lookup::{State, UnknownParentComponents};
-use crate::sync::block_lookups::{RootBlobsTuple, RootBlockTuple};
+use super::{DownloadedBlocks, PeerShouldHave};
+use crate::sync::block_lookups::single_block_lookup::{
+    Parent, RequestState, State, UnknownParentComponents,
+};
+use crate::sync::block_lookups::Lookup;
 use crate::sync::{manager::SLOT_IMPORT_TOLERANCE, network_context::SyncNetworkContext};
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::data_availability_checker::DataAvailabilityChecker;
 use beacon_chain::BeaconChainTypes;
+use itertools::Itertools;
 use lighthouse_network::PeerId;
 use std::sync::Arc;
 use store::Hash256;
 use strum::IntoStaticStr;
 use types::blob_sidecar::FixedBlobSidecarList;
-use types::{BlobSidecar, SignedBeaconBlock};
+use types::SignedBeaconBlock;
 
 /// How many attempts we try to find a parent of a block before we give up trying.
 pub(crate) const PARENT_FAIL_TOLERANCE: u8 = 5;
@@ -28,7 +31,7 @@ pub(crate) struct ParentLookup<T: BeaconChainTypes> {
     /// The blocks that have currently been downloaded.
     downloaded_blocks: Vec<DownloadedBlocks<T::EthSpec>>,
     /// Request of the last parent.
-    pub current_parent_request: SingleBlockLookup<PARENT_FAIL_TOLERANCE, T>,
+    pub current_parent_request: SingleBlockLookup<Parent, T>,
 }
 
 #[derive(Debug, PartialEq, Eq, IntoStaticStr)]
@@ -55,6 +58,7 @@ pub enum RequestError {
         cannot_process: bool,
     },
     NoPeers,
+    AlreadyDownloaded,
 }
 
 impl<T: BeaconChainTypes> ParentLookup<T> {
@@ -63,9 +67,15 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         parent_root: Hash256,
         peer_id: PeerShouldHave,
         da_checker: Arc<DataAvailabilityChecker<T>>,
+        cx: &SyncNetworkContext<T>,
     ) -> Self {
-        let current_parent_request =
-            SingleBlockLookup::new(parent_root, Some(<_>::default()), &[peer_id], da_checker);
+        let current_parent_request = SingleBlockLookup::new(
+            parent_root,
+            Some(<_>::default()),
+            &[peer_id],
+            da_checker,
+            cx,
+        );
 
         Self {
             chain_hash: block_root,
@@ -85,52 +95,15 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
     }
 
     /// Attempts to request the next unknown parent. If the request fails, it should be removed.
-    pub fn request_parent_block(
-        &mut self,
-        cx: &mut SyncNetworkContext<T>,
-    ) -> Result<(), RequestError> {
-        // check to make sure this request hasn't failed
-        if self.downloaded_blocks.len() + 1 >= PARENT_DEPTH_TOLERANCE {
-            return Err(RequestError::ChainTooLong);
-        }
-
-        if let Some((peer_id, request)) = self.current_parent_request.request_block()? {
-            match cx.parent_lookup_block_request(peer_id, request) {
-                Ok(request_id) => {
-                    self.current_parent_request.id.block_request_id = Some(request_id);
-                    return Ok(());
-                }
-                Err(reason) => {
-                    self.current_parent_request.id.block_request_id = None;
-                    return Err(RequestError::SendFailed(reason));
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn request_parent_blobs(
-        &mut self,
-        cx: &mut SyncNetworkContext<T>,
-    ) -> Result<(), RequestError> {
+    pub fn request_parent(&mut self, cx: &SyncNetworkContext<T>) -> Result<(), RequestError> {
         // check to make sure this request hasn't failed
         if self.downloaded_blocks.len() + 1 >= PARENT_DEPTH_TOLERANCE {
             return Err(RequestError::ChainTooLong);
         }
 
-        if let Some((peer_id, request)) = self.current_parent_request.request_blobs()? {
-            match cx.parent_lookup_blobs_request(peer_id, request) {
-                Ok(request_id) => {
-                    self.current_parent_request.id.blob_request_id = Some(request_id);
-                    return Ok(());
-                }
-                Err(reason) => {
-                    self.current_parent_request.id.blob_request_id = None;
-                    return Err(RequestError::SendFailed(reason));
-                }
-            }
-        }
-        Ok(())
+        self.current_parent_request
+            .request_block_and_blobs(cx)
+            .map_err(Into::into)
     }
 
     pub fn check_block_peer_disconnected(&mut self, peer_id: &PeerId) -> Result<(), ()> {
@@ -162,11 +135,9 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
             .block_request_state
             .requested_block_root = next_parent;
         self.current_parent_request.block_request_state.state.state = State::AwaitingDownload;
-        self.current_parent_request.id.block_request_id = None;
 
         // Update the blobs request.
         self.current_parent_request.blob_request_state.state.state = State::AwaitingDownload;
-        self.current_parent_request.id.blob_request_id = None;
 
         // Reset the unknown parent components.
         self.current_parent_request.unknown_parent_components =
@@ -176,25 +147,24 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
     pub fn add_current_request_block(&mut self, block: Arc<SignedBeaconBlock<T::EthSpec>>) {
         // Cache the block.
         self.current_parent_request.add_unknown_parent_block(block);
-
-        // Update the request.
-        self.current_parent_request.id.block_request_id = None;
     }
 
     pub fn add_current_request_blobs(&mut self, blobs: FixedBlobSidecarList<T::EthSpec>) {
         // Cache the blobs.
         self.current_parent_request.add_unknown_parent_blobs(blobs);
-
-        // Update the request.
-        self.current_parent_request.id.blob_request_id = None;
-    }
-
-    pub fn pending_block_response(&self, req_id: BlockRequestId) -> bool {
-        self.current_parent_request.id.block_request_id == Some(req_id)
     }
 
-    pub fn pending_blob_response(&self, req_id: BlobRequestId) -> bool {
-        self.current_parent_request.id.blob_request_id == Some(req_id)
+    pub fn processing_peer(&self) -> Result<PeerShouldHave, ()> {
+        self.current_parent_request
+            .block_request_state
+            .state
+            .processing_peer()
+            .or_else(|()| {
+                self.current_parent_request
+                    .blob_request_state
+                    .state
+                    .processing_peer()
+            })
     }
 
     /// Consumes the parent request and destructures it into it's parts.
@@ -205,7 +175,7 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         Hash256,
         Vec<RpcBlock<T::EthSpec>>,
         Vec<Hash256>,
-        SingleBlockLookup<PARENT_FAIL_TOLERANCE, T>,
+        SingleBlockLookup<Parent, T>,
     ) {
         let ParentLookup {
             chain_hash,
@@ -227,38 +197,11 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         self.chain_hash
     }
 
-    pub fn block_download_failed(&mut self) {
-        self.current_parent_request
-            .block_request_state
-            .state
-            .register_failure_downloading();
-        self.current_parent_request.id.block_request_id = None;
-    }
-
-    pub fn blob_download_failed(&mut self) {
-        self.current_parent_request
-            .blob_request_state
-            .state
-            .register_failure_downloading();
-        self.current_parent_request.id.blob_request_id = None;
-    }
-
-    pub fn block_processing_failed(&mut self) {
+    pub fn processing_failed(&mut self) {
         self.current_parent_request
             .block_request_state
             .state
             .register_failure_processing();
-        if let Some(components) = self
-            .current_parent_request
-            .unknown_parent_components
-            .as_mut()
-        {
-            components.downloaded_block = None;
-        }
-        self.current_parent_request.id.block_request_id = None;
-    }
-
-    pub fn blob_processing_failed(&mut self) {
         self.current_parent_request
             .blob_request_state
             .state
@@ -268,32 +211,34 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
             .unknown_parent_components
             .as_mut()
         {
+            components.downloaded_block = None;
             components.downloaded_blobs = <_>::default();
         }
-        self.current_parent_request.id.blob_request_id = None;
     }
 
     /// Verifies that the received block is what we requested. If so, parent lookup now waits for
     /// the processing result of the block.
-    pub fn verify_block(
+    pub fn verify_block<R: RequestState<Parent, T>>(
         &mut self,
-        block: Option<Arc<SignedBeaconBlock<T::EthSpec>>>,
+        block: Option<R::ResponseType>,
         failed_chains: &mut lru_cache::LRUTimeCache<Hash256>,
-    ) -> Result<Option<RootBlockTuple<T::EthSpec>>, ParentVerifyError> {
-        let root_and_block = self.current_parent_request.verify_block(block)?;
+    ) -> Result<Option<(Hash256, R::VerifiedResponseType)>, ParentVerifyError> {
+        let expected_block_root = self
+            .current_parent_request
+            .block_request_state
+            .requested_block_root;
+        let request_state = R::request_state_mut(&mut self.current_parent_request);
+        let root_and_block = request_state.verify_response(expected_block_root, block)?;
 
         // check if the parent of this block isn't in the failed cache. If it is, this chain should
         // be dropped and the peer downscored.
         if let Some(parent_root) = root_and_block
             .as_ref()
-            .map(|(_, block)| block.parent_root())
+            .map(|(_, block)| R::get_parent_root(block))
+            .flatten()
         {
             if failed_chains.contains(&parent_root) {
-                self.current_parent_request
-                    .block_request_state
-                    .state
-                    .register_failure_downloading();
-                self.current_parent_request.id.block_request_id = None;
+                request_state.register_failure_downloading();
                 return Err(ParentVerifyError::PreviousFailure { parent_root });
             }
         }
@@ -301,49 +246,24 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         Ok(root_and_block)
     }
 
-    pub fn verify_blob(
-        &mut self,
-        blob: Option<Arc<BlobSidecar<T::EthSpec>>>,
-        failed_chains: &mut lru_cache::LRUTimeCache<Hash256>,
-    ) -> Result<Option<RootBlobsTuple<T::EthSpec>>, ParentVerifyError> {
-        let parent_root_opt = blob.as_ref().map(|b| b.block_parent_root);
-        let blobs = self.current_parent_request.verify_blob(blob)?;
-
-        // check if the parent of this block isn't in the failed cache. If it is, this chain should
-        // be dropped and the peer downscored.
-        if let Some(parent_root) = parent_root_opt {
-            if failed_chains.contains(&parent_root) {
-                self.current_parent_request
-                    .blob_request_state
-                    .state
-                    .register_failure_downloading();
-                self.current_parent_request.id.blob_request_id = None;
-                return Err(ParentVerifyError::PreviousFailure { parent_root });
-            }
-        }
-
-        Ok(blobs)
-    }
-
     pub fn add_peers(&mut self, peer_source: &[PeerShouldHave]) {
         self.current_parent_request.add_peers(peer_source)
     }
 
-    pub fn used_peers(&self, response_type: ResponseType) -> impl Iterator<Item = &PeerId> + '_ {
-        match response_type {
-            ResponseType::Block => self
-                .current_parent_request
-                .block_request_state
-                .state
-                .used_peers
-                .iter(),
-            ResponseType::Blob => self
-                .current_parent_request
-                .blob_request_state
-                .state
-                .used_peers
-                .iter(),
-        }
+    pub fn used_peers(&self) -> impl Iterator<Item = &PeerId> + '_ {
+        self.current_parent_request
+            .block_request_state
+            .state
+            .used_peers
+            .iter()
+            .chain(
+                self.current_parent_request
+                    .blob_request_state
+                    .state
+                    .used_peers
+                    .iter(),
+            )
+            .unique()
     }
 }
 
@@ -371,6 +291,8 @@ impl From<LookupRequestError> for RequestError {
                 RequestError::TooManyAttempts { cannot_process }
             }
             E::NoPeers => RequestError::NoPeers,
+            E::AlreadyDownloaded => RequestError::AlreadyDownloaded,
+            E::SendFailed(msg) => RequestError::SendFailed(msg),
         }
     }
 }
@@ -398,6 +320,7 @@ impl RequestError {
             }
             RequestError::TooManyAttempts { cannot_process: _ } => "too_many_downloading_attempts",
             RequestError::NoPeers => "no_peers",
+            RequestError::AlreadyDownloaded => "already_downloaded",
         }
     }
 }
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index 90829905b8a..e3143f75f99 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -1,26 +1,59 @@
-use crate::sync::block_lookups::{BlobRequestId, BlockRequestId, RootBlobsTuple, RootBlockTuple};
+use super::{PeerShouldHave, ResponseType};
+use crate::sync::block_lookups::parent_lookup::RequestError::SendFailed;
+use crate::sync::block_lookups::parent_lookup::PARENT_FAIL_TOLERANCE;
+use crate::sync::block_lookups::{
+    BlockLookups, Id, LookupType, RootBlobsTuple, RootBlockTuple, SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS,
+};
+use crate::sync::manager::BlockProcessType;
 use crate::sync::network_context::SyncNetworkContext;
-use beacon_chain::block_verification_types::RpcBlock;
+use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
 use beacon_chain::data_availability_checker::DataAvailabilityChecker;
 use beacon_chain::{get_block_root, BeaconChainTypes};
+use itertools::Itertools;
 use lighthouse_network::rpc::methods::BlobsByRootRequest;
 use lighthouse_network::{rpc::BlocksByRootRequest, PeerId};
 use rand::seq::IteratorRandom;
+use slog::{debug, trace, Logger};
 use ssz_types::VariableList;
 use std::collections::HashSet;
+use std::marker::PhantomData;
 use std::ops::IndexMut;
 use std::sync::Arc;
+use std::time::Duration;
 use store::Hash256;
 use strum::IntoStaticStr;
 use types::blob_sidecar::{BlobIdentifier, FixedBlobSidecarList};
 use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
 
-use super::{PeerShouldHave, ResponseType};
+pub trait Lookup {
+    const MAX_ATTEMPTS: u8;
+    fn lookup_type() -> LookupType;
+    fn max_attempts() -> u8 {
+        Self::MAX_ATTEMPTS
+    }
+}
+
+pub struct Parent;
+pub struct Current;
+
+impl Lookup for Parent {
+    const MAX_ATTEMPTS: u8 = PARENT_FAIL_TOLERANCE;
+    fn lookup_type() -> LookupType {
+        LookupType::Parent
+    }
+}
 
-pub struct SingleBlockLookup<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> {
-    pub id: LookupId,
-    pub block_request_state: BlockRequestState<MAX_ATTEMPTS>,
-    pub blob_request_state: BlobRequestState<MAX_ATTEMPTS, T::EthSpec>,
+impl Lookup for Current {
+    const MAX_ATTEMPTS: u8 = SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS;
+    fn lookup_type() -> LookupType {
+        LookupType::Current
+    }
+}
+
+pub struct SingleBlockLookup<L: Lookup, T: BeaconChainTypes> {
+    pub id: Id,
+    pub block_request_state: BlockRequestState<L>,
+    pub blob_request_state: BlobRequestState<L, T::EthSpec>,
     pub da_checker: Arc<DataAvailabilityChecker<T>>,
     /// Only necessary for requests triggered by an `UnknownBlockParent` or `UnknownBlockParent` because any
     /// blocks or blobs without parents won't hit the data availability cache.
@@ -30,101 +63,418 @@ pub struct SingleBlockLookup<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> {
     pub triggered: bool,
 }
 
-#[derive(Default, Clone)]
-pub struct LookupId {
-    pub block_request_id: Option<BlockRequestId>,
-    pub blob_request_id: Option<BlobRequestId>,
+// generic across block + blob
+pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
+    type RequestType;
+    type ResponseType;
+    type ReconstructedResponseType;
+    type VerifiedResponseType;
+
+    // response verify
+    fn response_type() -> ResponseType;
+    fn get_parent_root(verified_response: &Self::VerifiedResponseType) -> Option<Hash256>;
+    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self;
+    fn add_to_parent_components(
+        verified_response: Self::VerifiedResponseType,
+        components: &mut UnknownParentComponents<T::EthSpec>,
+    );
+    fn verified_to_reconstructed(
+        verified: Self::VerifiedResponseType,
+    ) -> Self::ReconstructedResponseType;
+    fn send_for_processing(
+        id: Id,
+        bl: &mut BlockLookups<T>,
+        block_root: Hash256,
+        verified: Self::ReconstructedResponseType,
+        duration: Duration,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), ()>;
+
+    fn get_state(&self) -> &SingleLookupRequestState;
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState;
+    fn processing_peer(&self) -> Result<PeerShouldHave, ()> {
+        self.get_state().processing_peer()
+    }
+    fn downloading_peer(&self) -> Result<PeerShouldHave, ()> {
+        self.get_state().peer()
+    }
+    fn set_component_processed(&mut self) {
+        self.get_state_mut().component_processed = true;
+    }
+    fn new_request(&self) -> Self::RequestType;
+    fn max_attempts() -> u8;
+    fn retry_request(
+        id: Id,
+        cx: &SyncNetworkContext<T>,
+        peer_id: PeerId,
+        request: Self::RequestType,
+    ) -> Result<(), &'static str>;
+    fn verify_response(
+        &mut self,
+        expected_block_root: Hash256,
+        response: Option<Self::ResponseType>,
+    ) -> Result<Option<(Hash256, Self::VerifiedResponseType)>, LookupVerifyError> {
+        let request_state = self.get_state_mut();
+        match request_state.state {
+            State::AwaitingDownload => {
+                request_state.register_failure_downloading();
+                Err(LookupVerifyError::ExtraBlocksReturned)
+            }
+            State::Downloading { peer_id } => {
+                self.verify_response_inner(expected_block_root, response, peer_id)
+            }
+            State::Processing { peer_id: _ } => match response {
+                Some(_) => {
+                    // We sent the block for processing and received an extra block.
+                    request_state.register_failure_downloading();
+                    Err(LookupVerifyError::ExtraBlocksReturned)
+                }
+                None => {
+                    // This is simply the stream termination and we are already processing the
+                    // block
+                    Ok(None)
+                }
+            },
+        }
+    }
+    fn verify_response_inner(
+        &mut self,
+        expected_block_root: Hash256,
+        response: Option<Self::ResponseType>,
+        peer_id: PeerShouldHave,
+    ) -> Result<Option<(Hash256, Self::VerifiedResponseType)>, LookupVerifyError>;
+
+    fn retry_request_after_failure(
+        &mut self,
+        id: Id,
+        cx: &SyncNetworkContext<T>,
+        log: &Logger,
+    ) -> Result<(), ()> {
+        if let Err(e) = self
+            .build_request()
+            .map_err(Into::into)
+            .and_then(|(peer_id, request)| Self::retry_request(id, cx, peer_id, request))
+        {
+            //TODO(sean) pass this error up? check downloaded contents prior to retry-ing?
+            debug!(log, "Single block lookup failed";
+                    "error" => ?e,
+            );
+            return Err(());
+        }
+        Ok(())
+    }
+    fn build_request(&mut self) -> Result<(PeerId, Self::RequestType), LookupRequestError> {
+        debug_assert!(matches!(self.get_state().state, State::AwaitingDownload));
+        self.too_many_attempts()?;
+        let peer = self.get_peer()?;
+        let request = self.new_request();
+        Ok((peer, request))
+    }
+    fn too_many_attempts(&self) -> Result<(), LookupRequestError> {
+        let max_attempts = Self::max_attempts();
+        if self.get_state().failed_attempts() >= max_attempts {
+            Err(LookupRequestError::TooManyAttempts {
+                cannot_process: self.cannot_process(),
+            })
+        } else {
+            Ok(())
+        }
+    }
+    fn cannot_process(&self) -> bool {
+        let request_state = self.get_state();
+        request_state.failed_processing >= request_state.failed_downloading
+    }
+    fn get_peer(&mut self) -> Result<PeerId, LookupRequestError> {
+        let mut request_state = self.get_state_mut();
+        let Some(peer_id) =         request_state
+            .available_peers
+            .iter()
+            .choose(&mut rand::thread_rng())
+            .copied()
+            .map(PeerShouldHave::BlockAndBlobs).or(request_state
+            .potential_peers
+            .iter()
+            .choose(&mut rand::thread_rng())
+            .copied()
+            .map(PeerShouldHave::Neither)) else {
+           return Err(LookupRequestError::NoPeers);
+        };
+        request_state.used_peers.insert(peer_id.to_peer_id());
+        request_state.state = State::Downloading { peer_id };
+        Ok(peer_id.to_peer_id())
+    }
+    fn check_peer_disconnected(&mut self, peer: &PeerId) -> Result<(), ()> {
+        self.get_state_mut().check_peer_disconnected(peer)
+    }
+    fn remove_if_useless(&mut self, peer: &PeerId) {
+        self.get_state_mut().remove_peer_if_useless(peer)
+    }
+    fn downloading(&self) -> bool {
+        matches!(self.get_state().state, State::Downloading { .. })
+    }
+    fn register_failure_downloading(&mut self) {
+        self.get_state_mut().register_failure_downloading()
+    }
 }
 
-pub struct BlobRequestState<const MAX_ATTEMPTS: u8, T: EthSpec> {
+impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlockRequestState<L> {
+    type RequestType = BlocksByRootRequest;
+    type ResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
+    type ReconstructedResponseType = RpcBlock<T::EthSpec>;
+    type VerifiedResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
+
+    // response verify
+    fn response_type() -> ResponseType {
+        ResponseType::Block
+    }
+
+    fn get_parent_root(verified_response: &Arc<SignedBeaconBlock<T::EthSpec>>) -> Option<Hash256> {
+        Some(verified_response.parent_root())
+    }
+    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
+        &mut request.block_request_state
+    }
+    fn add_to_parent_components(
+        verified_response: Arc<SignedBeaconBlock<T::EthSpec>>,
+        components: &mut UnknownParentComponents<T::EthSpec>,
+    ) {
+        components.add_unknown_parent_block(verified_response);
+    }
+
+    fn verified_to_reconstructed(
+        block: Arc<SignedBeaconBlock<T::EthSpec>>,
+    ) -> RpcBlock<T::EthSpec> {
+        RpcBlock::new_without_blobs(block)
+    }
+
+    fn send_for_processing(
+        id: Id,
+        bl: &mut BlockLookups<T>,
+        block_root: Hash256,
+        constructed: RpcBlock<T::EthSpec>,
+        duration: Duration,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), ()> {
+        bl.send_block_for_processing(
+            block_root,
+            constructed,
+            duration,
+            BlockProcessType::SingleBlock { id },
+            cx,
+        )
+    }
+
+    fn get_state(&self) -> &SingleLookupRequestState {
+        &self.state
+    }
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
+        &mut self.state
+    }
+    fn new_request(&self) -> BlocksByRootRequest {
+        BlocksByRootRequest::new(VariableList::from(vec![self.requested_block_root]))
+    }
+    fn max_attempts() -> u8 {
+        L::MAX_ATTEMPTS
+    }
+    fn retry_request(
+        id: Id,
+        cx: &SyncNetworkContext<T>,
+        peer_id: PeerId,
+        request: Self::RequestType,
+    ) -> Result<(), &'static str> {
+        cx.single_block_lookup_request_retry(id, peer_id, request, L::lookup_type())
+    }
+
+    fn verify_response_inner(
+        &mut self,
+        expected_block_root: Hash256,
+        response: Option<Self::ResponseType>,
+        peer_id: PeerShouldHave,
+    ) -> Result<Option<RootBlockTuple<T::EthSpec>>, LookupVerifyError> {
+        match response {
+            Some(block) => {
+                // Compute the block root using this specific function so that we can get timing
+                // metrics.
+                let block_root = get_block_root(&block);
+                if block_root != expected_block_root {
+                    // return an error and drop the block
+                    // NOTE: we take this is as a download failure to prevent counting the
+                    // attempt as a chain failure, but simply a peer failure.
+                    self.state.register_failure_downloading();
+                    Err(LookupVerifyError::RootMismatch)
+                } else {
+                    // Return the block for processing.
+                    self.state.state = State::Processing { peer_id };
+                    Ok(Some((block_root, block)))
+                }
+            }
+            None => {
+                if peer_id.should_have_block() {
+                    self.state.register_failure_downloading();
+                    Err(LookupVerifyError::NoBlockReturned)
+                } else {
+                    self.state.state = State::AwaitingDownload;
+                    Err(LookupVerifyError::BenignFailure)
+                }
+            }
+        }
+    }
+}
+
+impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlobRequestState<L, T::EthSpec> {
+    type RequestType = BlobsByRootRequest;
+    type ResponseType = Arc<BlobSidecar<T::EthSpec>>;
+    type ReconstructedResponseType = FixedBlobSidecarList<T::EthSpec>;
+    type VerifiedResponseType = FixedBlobSidecarList<T::EthSpec>;
+
+    // response verify
+    fn response_type() -> ResponseType {
+        ResponseType::Blob
+    }
+
+    fn get_parent_root(verified_response: &FixedBlobSidecarList<T::EthSpec>) -> Option<Hash256> {
+        verified_response
+            .into_iter()
+            .filter_map(|blob| blob.as_ref())
+            .map(|blob| blob.block_parent_root)
+            .next()
+    }
+    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
+        &mut request.blob_request_state
+    }
+    fn add_to_parent_components(
+        verified_response: FixedBlobSidecarList<T::EthSpec>,
+        components: &mut UnknownParentComponents<T::EthSpec>,
+    ) {
+        components.add_unknown_parent_blobs(verified_response);
+    }
+    fn verified_to_reconstructed(
+        blobs: FixedBlobSidecarList<T::EthSpec>,
+    ) -> FixedBlobSidecarList<T::EthSpec> {
+        blobs
+    }
+
+    fn send_for_processing(
+        id: Id,
+        bl: &mut BlockLookups<T>,
+        block_root: Hash256,
+        verified: FixedBlobSidecarList<T::EthSpec>,
+        duration: Duration,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), ()> {
+        bl.send_blobs_for_processing(
+            block_root,
+            verified,
+            duration,
+            BlockProcessType::SingleBlob { id },
+            cx,
+        )
+    }
+
+    fn get_state(&self) -> &SingleLookupRequestState {
+        &self.state
+    }
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
+        &mut self.state
+    }
+    fn new_request(&self) -> BlobsByRootRequest {
+        BlobsByRootRequest {
+            blob_ids: VariableList::from(self.requested_ids.clone()),
+        }
+    }
+    fn max_attempts() -> u8 {
+        L::MAX_ATTEMPTS
+    }
+    fn retry_request(
+        id: Id,
+        cx: &SyncNetworkContext<T>,
+        peer_id: PeerId,
+        request: Self::RequestType,
+    ) -> Result<(), &'static str> {
+        cx.single_blob_lookup_request_retry(id, peer_id, request, L::lookup_type())
+    }
+
+    fn verify_response_inner(
+        &mut self,
+        expected_block_root: Hash256,
+        blob: Option<Self::ResponseType>,
+        peer_id: PeerShouldHave,
+    ) -> Result<Option<RootBlobsTuple<T::EthSpec>>, LookupVerifyError> {
+        match blob {
+            Some(blob) => {
+                let received_id = blob.id();
+                if !self.requested_ids.contains(&received_id) {
+                    self.state.register_failure_downloading();
+                    Err(LookupVerifyError::UnrequestedBlobId)
+                } else {
+                    // State should remain downloading until we receive the stream terminator.
+                    self.requested_ids.retain(|id| *id != received_id);
+                    let blob_index = blob.index;
+
+                    if blob_index >= T::EthSpec::max_blobs_per_block() as u64 {
+                        return Err(LookupVerifyError::InvalidIndex(blob.index));
+                    }
+                    *self.blob_download_queue.index_mut(blob_index as usize) = Some(blob);
+                    Ok(None)
+                }
+            }
+            None => {
+                self.state.state = State::Processing { peer_id };
+                let blobs = std::mem::take(&mut self.blob_download_queue);
+                Ok(Some((expected_block_root, blobs)))
+            }
+        }
+    }
+}
+
+pub struct BlobRequestState<L: Lookup, T: EthSpec> {
     pub requested_ids: Vec<BlobIdentifier>,
     /// Where we store blobs until we receive the stream terminator.
     pub blob_download_queue: FixedBlobSidecarList<T>,
-    pub state: SingleLookupRequestState<MAX_ATTEMPTS>,
+    pub state: SingleLookupRequestState,
+    _phantom: PhantomData<L>,
 }
 
-impl<const MAX_ATTEMPTS: u8, T: EthSpec> BlobRequestState<MAX_ATTEMPTS, T> {
+impl<L: Lookup, T: EthSpec> BlobRequestState<L, T> {
     pub fn new(peer_source: &[PeerShouldHave]) -> Self {
         Self {
             requested_ids: <_>::default(),
             blob_download_queue: <_>::default(),
             state: SingleLookupRequestState::new(peer_source),
+            _phantom: PhantomData::default(),
         }
     }
 }
 
-pub struct BlockRequestState<const MAX_ATTEMPTS: u8> {
+pub struct BlockRequestState<L: Lookup> {
     pub requested_block_root: Hash256,
-    pub state: SingleLookupRequestState<MAX_ATTEMPTS>,
+    pub state: SingleLookupRequestState,
+    _phantom: PhantomData<L>,
 }
 
-impl<const MAX_ATTEMPTS: u8> BlockRequestState<MAX_ATTEMPTS> {
+impl<L: Lookup> BlockRequestState<L> {
     pub fn new(block_root: Hash256, peers: &[PeerShouldHave]) -> Self {
         Self {
             requested_block_root: block_root,
             state: SingleLookupRequestState::new(peers),
+            _phantom: PhantomData::default(),
         }
     }
 }
 
-impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS, T> {
-    pub(crate) fn register_failure_downloading(&mut self, response_type: ResponseType) {
-        match response_type {
-            ResponseType::Block => self
-                .block_request_state
-                .state
-                .register_failure_downloading(),
-            ResponseType::Blob => self.blob_request_state.state.register_failure_downloading(),
-        }
-    }
-}
-
-impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS, T> {
-    pub(crate) fn downloading(&mut self, response_type: ResponseType) -> bool {
-        match response_type {
-            ResponseType::Block => {
-                matches!(
-                    self.block_request_state.state.state,
-                    State::Downloading { .. }
-                )
-            }
-            ResponseType::Blob => {
-                matches!(
-                    self.blob_request_state.state.state,
-                    State::Downloading { .. }
-                )
-            }
-        }
-    }
-
-    pub(crate) fn remove_peer_if_useless(&mut self, peer_id: &PeerId, response_type: ResponseType) {
-        match response_type {
-            ResponseType::Block => self
-                .block_request_state
-                .state
-                .remove_peer_if_useless(peer_id),
-            ResponseType::Blob => self
-                .blob_request_state
-                .state
-                .remove_peer_if_useless(peer_id),
+impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
+    pub(crate) fn block_already_downloaded(&self) -> bool {
+        if let Some(components) = self.unknown_parent_components.as_ref() {
+            components.downloaded_block.is_some()
+        } else {
+            self.da_checker
+                .has_block(&self.block_request_state.requested_block_root)
         }
     }
 
-    pub(crate) fn check_peer_disconnected(
-        &mut self,
-        peer_id: &PeerId,
-        response_type: ResponseType,
-    ) -> Result<(), ()> {
-        match response_type {
-            ResponseType::Block => self
-                .block_request_state
-                .state
-                .check_peer_disconnected(peer_id),
-            ResponseType::Blob => self
-                .blob_request_state
-                .state
-                .check_peer_disconnected(peer_id),
-        }
+    pub(crate) fn blobs_already_downloaded(&mut self) -> bool {
+        self.update_blobs_request();
+        self.blob_request_state.requested_ids.is_empty()
     }
 }
 
@@ -179,7 +529,7 @@ impl<E: EthSpec> UnknownParentComponents<E> {
 
 /// Object representing the state of a single block or blob lookup request.
 #[derive(PartialEq, Eq, Debug)]
-pub struct SingleLookupRequestState<const MAX_ATTEMPTS: u8> {
+pub struct SingleLookupRequestState {
     /// State of this request.
     pub state: State,
     /// Peers that should have this block or blob.
@@ -225,17 +575,20 @@ pub enum LookupRequestError {
         cannot_process: bool,
     },
     NoPeers,
+    SendFailed(&'static str),
+    AlreadyDownloaded,
 }
 
-impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS, T> {
+impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
     pub fn new(
         requested_block_root: Hash256,
         unknown_parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
         da_checker: Arc<DataAvailabilityChecker<T>>,
+        cx: &SyncNetworkContext<T>,
     ) -> Self {
         Self {
-            id: <_>::default(),
+            id: cx.next_id(),
             block_request_state: BlockRequestState::new(requested_block_root, peers),
             blob_request_state: BlobRequestState::new(peers),
             da_checker,
@@ -251,27 +604,60 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS
     /// Send the necessary request for blobs and blocks and update `self.id` with the latest
     /// request `Id`s. This will return `Err(())` if neither the block nor blob request could be made
     /// or are no longer required.
-    pub fn request_block_and_blobs(&mut self, cx: &mut SyncNetworkContext<T>) -> Result<(), ()> {
-        let block_request_id = if let Ok(Some((peer_id, block_request))) = self.request_block() {
-            cx.single_block_lookup_request(peer_id, block_request).ok()
-        } else {
-            None
-        };
-
-        let blob_request_id = if let Ok(Some((peer_id, blob_request))) = self.request_blobs() {
-            cx.single_blobs_lookup_request(peer_id, blob_request).ok()
-        } else {
-            None
-        };
-
-        if block_request_id.is_none() && blob_request_id.is_none() {
-            return Err(());
+    pub fn request_block_and_blobs(
+        &mut self,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        let block_root = self.block_request_state.requested_block_root;
+        if self.block_already_downloaded() && self.blobs_already_downloaded() {
+            // drop lookup
+            trace!(cx.log, "Lookup request already completed"; "block_root"=> ?block_root);
+            return Err(LookupRequestError::AlreadyDownloaded);
         }
 
-        self.id = LookupId {
-            block_request_id,
-            blob_request_id,
+        let (block_peer_id, block_request) =
+            match <BlockRequestState<L> as RequestState<L, T>>::build_request(
+                &mut self.block_request_state,
+            ) {
+                Ok(opt) => opt,
+                Err(e) => {
+                    // drop lookup
+                    debug!(cx.log,
+                        "Lookup request block error, dropping lookup";
+                        "block_root"=> ?block_root,
+                        "error"=> ?e
+                    );
+                    return Err(e);
+                }
+            };
+
+        let (blob_peer_id, blob_request) = match <BlobRequestState<
+            L,
+            <T as BeaconChainTypes>::EthSpec,
+        > as RequestState<L, T>>::build_request(
+            &mut self.blob_request_state
+        ) {
+            Ok(opt) => opt,
+            Err(e) => {
+                // drop lookup
+                debug!(cx.log,
+                    "Lookup request blob error, dropping lookup";
+                    "block_root"=> ?block_root,
+                    "error"=> ?e
+                );
+                return Err(e);
+            }
         };
+
+        cx.single_lookup_request(
+            self.id,
+            block_peer_id,
+            block_request,
+            blob_peer_id,
+            blob_request,
+            L::lookup_type(),
+        )
+        .map_err(LookupRequestError::SendFailed)?;
         Ok(())
     }
 
@@ -368,268 +754,6 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS
         }
     }
 
-    /// Verifies if the received block matches the requested one.
-    /// Returns the block for processing if the response is what we expected.
-    pub fn verify_block(
-        &mut self,
-        block: Option<Arc<SignedBeaconBlock<T::EthSpec>>>,
-    ) -> Result<Option<RootBlockTuple<T::EthSpec>>, LookupVerifyError> {
-        match self.block_request_state.state.state {
-            State::AwaitingDownload => {
-                self.block_request_state
-                    .state
-                    .register_failure_downloading();
-                Err(LookupVerifyError::ExtraBlocksReturned)
-            }
-            State::Downloading { peer_id } => {
-                match block {
-                    Some(block) => {
-                        // Compute the block root using this specific function so that we can get timing
-                        // metrics.
-                        let block_root = get_block_root(&block);
-                        if block_root != self.block_request_state.requested_block_root {
-                            // return an error and drop the block
-                            // NOTE: we take this is as a download failure to prevent counting the
-                            // attempt as a chain failure, but simply a peer failure.
-                            self.block_request_state
-                                .state
-                                .register_failure_downloading();
-                            Err(LookupVerifyError::RootMismatch)
-                        } else {
-                            // Return the block for processing.
-                            self.block_request_state.state.state = State::Processing { peer_id };
-                            Ok(Some((block_root, block)))
-                        }
-                    }
-                    None => {
-                        if peer_id.should_have_block() {
-                            self.block_request_state
-                                .state
-                                .register_failure_downloading();
-                            Err(LookupVerifyError::NoBlockReturned)
-                        } else {
-                            self.block_request_state.state.state = State::AwaitingDownload;
-                            Err(LookupVerifyError::BenignFailure)
-                        }
-                    }
-                }
-            }
-            State::Processing { peer_id: _ } => match block {
-                Some(_) => {
-                    // We sent the block for processing and received an extra block.
-                    self.block_request_state
-                        .state
-                        .register_failure_downloading();
-                    Err(LookupVerifyError::ExtraBlocksReturned)
-                }
-                None => {
-                    // This is simply the stream termination and we are already processing the
-                    // block
-                    Ok(None)
-                }
-            },
-        }
-    }
-
-    pub fn verify_blob(
-        &mut self,
-        blob: Option<Arc<BlobSidecar<T::EthSpec>>>,
-    ) -> Result<Option<RootBlobsTuple<T::EthSpec>>, LookupVerifyError> {
-        match self.blob_request_state.state.state {
-            State::AwaitingDownload => {
-                self.blob_request_state.state.register_failure_downloading();
-                Err(LookupVerifyError::ExtraBlobsReturned)
-            }
-            State::Downloading {
-                peer_id: peer_source,
-            } => match blob {
-                Some(blob) => {
-                    let received_id = blob.id();
-                    if !self.blob_request_state.requested_ids.contains(&received_id) {
-                        self.blob_request_state.state.register_failure_downloading();
-                        Err(LookupVerifyError::UnrequestedBlobId)
-                    } else {
-                        // State should remain downloading until we receive the stream terminator.
-                        self.blob_request_state
-                            .requested_ids
-                            .retain(|id| *id != received_id);
-                        let blob_index = blob.index;
-
-                        if blob_index >= T::EthSpec::max_blobs_per_block() as u64 {
-                            return Err(LookupVerifyError::InvalidIndex(blob.index));
-                        }
-                        *self
-                            .blob_request_state
-                            .blob_download_queue
-                            .index_mut(blob_index as usize) = Some(blob);
-                        Ok(None)
-                    }
-                }
-                None => {
-                    self.blob_request_state.state.state = State::Processing {
-                        peer_id: peer_source,
-                    };
-                    Ok(Some((
-                        self.block_request_state.requested_block_root,
-                        std::mem::take(&mut self.blob_request_state.blob_download_queue),
-                    )))
-                }
-            },
-            State::Processing { peer_id: _ } => match blob {
-                Some(_) => {
-                    // We sent the blob for processing and received an extra blob.
-                    self.blob_request_state.state.register_failure_downloading();
-                    Err(LookupVerifyError::ExtraBlobsReturned)
-                }
-                None => {
-                    // This is simply the stream termination and we are already processing the
-                    // block
-                    Ok(None)
-                }
-            },
-        }
-    }
-
-    pub fn request_block(
-        &mut self,
-    ) -> Result<Option<(PeerId, BlocksByRootRequest)>, LookupRequestError> {
-        let block_already_downloaded =
-            if let Some(components) = self.unknown_parent_components.as_ref() {
-                components.downloaded_block.is_some()
-            } else {
-                self.da_checker
-                    .has_block(&self.block_request_state.requested_block_root)
-            };
-
-        if block_already_downloaded {
-            return Ok(None);
-        }
-
-        debug_assert!(matches!(
-            self.block_request_state.state.state,
-            State::AwaitingDownload
-        ));
-        let request = BlocksByRootRequest::new(VariableList::from(vec![
-            self.block_request_state.requested_block_root,
-        ]));
-        let response_type = ResponseType::Block;
-        if self.too_many_attempts(response_type) {
-            Err(LookupRequestError::TooManyAttempts {
-                cannot_process: self.cannot_process(response_type),
-            })
-        } else if let Some(peer_id) = self.get_peer(response_type) {
-            self.add_used_peer(peer_id, response_type);
-            Ok(Some((peer_id.to_peer_id(), request)))
-        } else {
-            Err(LookupRequestError::NoPeers)
-        }
-    }
-
-    pub fn request_blobs(
-        &mut self,
-    ) -> Result<Option<(PeerId, BlobsByRootRequest)>, LookupRequestError> {
-        self.update_blobs_request();
-
-        if self.blob_request_state.requested_ids.is_empty() {
-            return Ok(None);
-        }
-
-        debug_assert!(matches!(
-            self.blob_request_state.state.state,
-            State::AwaitingDownload
-        ));
-        let request = BlobsByRootRequest {
-            blob_ids: VariableList::from(self.blob_request_state.requested_ids.clone()),
-        };
-        let response_type = ResponseType::Blob;
-        if self.too_many_attempts(response_type) {
-            Err(LookupRequestError::TooManyAttempts {
-                cannot_process: self.cannot_process(response_type),
-            })
-        } else if let Some(peer_id) = self.get_peer(response_type) {
-            self.add_used_peer(peer_id, response_type);
-            Ok(Some((peer_id.to_peer_id(), request)))
-        } else {
-            Err(LookupRequestError::NoPeers)
-        }
-    }
-
-    fn too_many_attempts(&self, response_type: ResponseType) -> bool {
-        match response_type {
-            ResponseType::Block => self.block_request_state.state.failed_attempts() >= MAX_ATTEMPTS,
-            ResponseType::Blob => self.blob_request_state.state.failed_attempts() >= MAX_ATTEMPTS,
-        }
-    }
-
-    fn cannot_process(&self, response_type: ResponseType) -> bool {
-        match response_type {
-            ResponseType::Block => {
-                self.block_request_state.state.failed_processing
-                    >= self.block_request_state.state.failed_downloading
-            }
-            ResponseType::Blob => {
-                self.blob_request_state.state.failed_processing
-                    >= self.blob_request_state.state.failed_downloading
-            }
-        }
-    }
-
-    fn get_peer(&self, response_type: ResponseType) -> Option<PeerShouldHave> {
-        match response_type {
-            ResponseType::Block => self
-                .block_request_state
-                .state
-                .available_peers
-                .iter()
-                .choose(&mut rand::thread_rng())
-                .copied()
-                .map(PeerShouldHave::BlockAndBlobs)
-                .or(self
-                    .block_request_state
-                    .state
-                    .potential_peers
-                    .iter()
-                    .choose(&mut rand::thread_rng())
-                    .copied()
-                    .map(PeerShouldHave::Neither)),
-            ResponseType::Blob => self
-                .blob_request_state
-                .state
-                .available_peers
-                .iter()
-                .choose(&mut rand::thread_rng())
-                .copied()
-                .map(PeerShouldHave::BlockAndBlobs)
-                .or(self
-                    .blob_request_state
-                    .state
-                    .potential_peers
-                    .iter()
-                    .choose(&mut rand::thread_rng())
-                    .copied()
-                    .map(PeerShouldHave::Neither)),
-        }
-    }
-
-    fn add_used_peer(&mut self, peer_id: PeerShouldHave, response_type: ResponseType) {
-        match response_type {
-            ResponseType::Block => {
-                self.block_request_state
-                    .state
-                    .used_peers
-                    .insert(peer_id.to_peer_id());
-                self.block_request_state.state.state = State::Downloading { peer_id };
-            }
-            ResponseType::Blob => {
-                self.blob_request_state
-                    .state
-                    .used_peers
-                    .insert(peer_id.to_peer_id());
-                self.blob_request_state.state.state = State::Downloading { peer_id };
-            }
-        }
-    }
-
     pub fn add_peers(&mut self, peers: &[PeerShouldHave]) {
         for peer in peers {
             match peer {
@@ -645,34 +769,48 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> SingleBlockLookup<MAX_ATTEMPTS
         }
     }
 
-    pub fn processing_peer(&self, response_type: ResponseType) -> Result<PeerShouldHave, ()> {
-        match response_type {
-            ResponseType::Block => self.block_request_state.state.processing_peer(),
-            ResponseType::Blob => self.blob_request_state.state.processing_peer(),
-        }
-    }
-
-    pub fn downloading_peer(&self, response_type: ResponseType) -> Result<PeerShouldHave, ()> {
-        match response_type {
-            ResponseType::Block => self.block_request_state.state.peer(),
-            ResponseType::Blob => self.blob_request_state.state.peer(),
-        }
-    }
-
     pub fn both_components_processed(&self) -> bool {
         self.block_request_state.state.component_processed
             && self.blob_request_state.state.component_processed
     }
 
-    pub fn set_component_processed(&mut self, response_type: ResponseType) {
-        match response_type {
-            ResponseType::Block => self.block_request_state.state.component_processed = true,
-            ResponseType::Blob => self.blob_request_state.state.component_processed = true,
-        }
+    pub fn should_remove_disconnected_peer(
+        &mut self,
+        id: Id,
+        peer_id: &PeerId,
+        cx: &SyncNetworkContext<T>,
+        log: &Logger,
+    ) -> bool {
+        let useless_block_peer =
+            if <BlockRequestState<L> as RequestState<L, T>>::check_peer_disconnected(
+                &mut self.block_request_state,
+                peer_id,
+            )
+            .is_err()
+            {
+                trace!(log, "Single lookup failed on peer disconnection"; "block_root" => ?self.block_request_state.requested_block_root, "response_type" => ?ResponseType::Block);
+                self.block_request_state
+                    .retry_request_after_failure(id, cx, log)
+                    .is_err()
+            } else {
+                false
+            };
+        let useless_blob_peer = if <BlobRequestState<L, <T as BeaconChainTypes>::EthSpec> as RequestState<L, T>>::check_peer_disconnected(&mut self
+                                                                                                                                                      .blob_request_state, peer_id)
+            .is_err()
+        {
+            trace!(log, "Single lookup failed on peer disconnection"; "block_root" => ?self.block_request_state.requested_block_root, "response_type" => ?ResponseType::Blob);
+            self.blob_request_state
+                .retry_request_after_failure(id, cx, log)
+                .is_err()
+        } else {
+            false
+        };
+        useless_block_peer && useless_blob_peer
     }
 }
 
-impl<const MAX_ATTEMPTS: u8> SingleLookupRequestState<MAX_ATTEMPTS> {
+impl SingleLookupRequestState {
     pub fn new(peers: &[PeerShouldHave]) -> Self {
         let mut available_peers = HashSet::default();
         let mut potential_peers = HashSet::default();
@@ -763,9 +901,7 @@ impl<const MAX_ATTEMPTS: u8> SingleLookupRequestState<MAX_ATTEMPTS> {
     }
 }
 
-impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> slog::Value
-    for SingleBlockLookup<MAX_ATTEMPTS, T>
-{
+impl<L: Lookup, T: BeaconChainTypes> slog::Value for SingleBlockLookup<L, T> {
     fn serialize(
         &self,
         _record: &slog::Record,
@@ -773,6 +909,7 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> slog::Value
         serializer: &mut dyn slog::Serializer,
     ) -> slog::Result {
         serializer.emit_str("request", key)?;
+        serializer.emit_arguments("lookup_type", &format_args!("{:?}", L::lookup_type()))?;
         serializer.emit_arguments(
             "hash",
             &format_args!("{}", self.block_request_state.requested_block_root),
@@ -793,7 +930,7 @@ impl<const MAX_ATTEMPTS: u8, T: BeaconChainTypes> slog::Value
     }
 }
 
-impl<const MAX_ATTEMPTS: u8> slog::Value for SingleLookupRequestState<MAX_ATTEMPTS> {
+impl slog::Value for SingleLookupRequestState {
     fn serialize(
         &self,
         record: &slog::Record,
diff --git a/beacon_node/network/src/sync/block_lookups/tests.rs b/beacon_node/network/src/sync/block_lookups/tests.rs
index 561593e6d14..12f345ac7e1 100644
--- a/beacon_node/network/src/sync/block_lookups/tests.rs
+++ b/beacon_node/network/src/sync/block_lookups/tests.rs
@@ -304,7 +304,7 @@ fn test_single_block_lookup_happy_path() {
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_block_lookup_response(id, peer_id, Some(block.into()), D, &mut cx);
+    bl.single_lookup_response(id, peer_id, Some(block.into()), D, &mut cx);
     rig.expect_empty_network();
     rig.expect_block_process(response_type);
 
@@ -313,7 +313,7 @@ fn test_single_block_lookup_happy_path() {
 
     // Send the stream termination. Peer should have not been penalized, and the request removed
     // after processing.
-    bl.single_block_lookup_response(id, peer_id, None, D, &mut cx);
+    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
     bl.single_block_component_processed(
         id,
         BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
@@ -346,7 +346,7 @@ fn test_single_block_lookup_empty_response() {
     }
 
     // The peer does not have the block. It should be penalized.
-    bl.single_block_lookup_response(id, peer_id, None, D, &mut cx);
+    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
     rig.expect_penalty();
 
     rig.expect_block_request(response_type); // it should be retried
@@ -375,12 +375,12 @@ fn test_single_block_lookup_wrong_response() {
 
     // Peer sends something else. It should be penalized.
     let bad_block = rig.rand_block(fork_name);
-    bl.single_block_lookup_response(id, peer_id, Some(bad_block.into()), D, &mut cx);
+    bl.single_lookup_response(id, peer_id, Some(bad_block.into()), D, &mut cx);
     rig.expect_penalty();
     rig.expect_block_request(response_type); // should be retried
 
     // Send the stream termination. This should not produce an additional penalty.
-    bl.single_block_lookup_response(id, peer_id, None, D, &mut cx);
+    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
     rig.expect_empty_network();
 }
 
@@ -438,7 +438,7 @@ fn test_single_block_lookup_becomes_parent_request() {
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_block_lookup_response(id, peer_id, Some(block.clone()), D, &mut cx);
+    bl.single_lookup_response(id, peer_id, Some(block.clone()), D, &mut cx);
     rig.expect_empty_network();
     rig.expect_block_process(response_type);
 
@@ -971,7 +971,7 @@ fn test_single_block_lookup_ignored_response() {
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_block_lookup_response(id, peer_id, Some(block.into()), D, &mut cx);
+    bl.single_lookup_response(id, peer_id, Some(block.into()), D, &mut cx);
     rig.expect_empty_network();
     rig.expect_block_process(response_type);
 
@@ -980,7 +980,7 @@ fn test_single_block_lookup_ignored_response() {
 
     // Send the stream termination. Peer should have not been penalized, and the request removed
     // after processing.
-    bl.single_block_lookup_response(id, peer_id, None, D, &mut cx);
+    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
     // Send an Ignored response, the request should be dropped
     bl.single_block_component_processed(id, BlockProcessingResult::Ignored, response_type, &mut cx);
     rig.expect_empty_network();
@@ -1353,7 +1353,7 @@ mod deneb_only {
         fn block_response(mut self) -> Self {
             // The peer provides the correct block, should not be penalized. Now the block should be sent
             // for processing.
-            self.bl.single_block_lookup_response(
+            self.bl.single_lookup_response(
                 self.block_req_id.expect("block request id"),
                 self.peer_id,
                 self.block.clone(),
@@ -1402,7 +1402,7 @@ mod deneb_only {
         }
 
         fn empty_block_response(mut self) -> Self {
-            self.bl.single_block_lookup_response(
+            self.bl.single_lookup_response(
                 self.block_req_id.expect("block request id"),
                 self.peer_id,
                 None,
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index 5e8fc4a4e9e..31062336580 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -43,8 +43,9 @@ use crate::service::NetworkMessage;
 use crate::status::ToStatusMessage;
 use crate::sync::block_lookups::delayed_lookup;
 use crate::sync::block_lookups::delayed_lookup::DelayedLookupMessage;
-pub use crate::sync::block_lookups::ResponseType;
-use crate::sync::block_lookups::UnknownParentComponents;
+use crate::sync::block_lookups::{
+    BlobRequestState, BlockRequestState, Current, Parent, RequestState, UnknownParentComponents,
+};
 use crate::sync::range_sync::ByRangeRequestType;
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::block_verification_types::RpcBlock;
@@ -83,27 +84,47 @@ pub const DELAY_QUEUE_CHANNEL_SIZE: usize = 128;
 
 pub type Id = u32;
 
+#[derive(Debug)]
+pub enum ResponseType {
+    Block,
+    Blob,
+}
+
 /// Id of rpc requests sent by sync to the network.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum RequestId {
     /// Request searching for a block given a hash.
-    SingleBlock { id: Id },
+    SingleBlock {
+        id: Id,
+    },
+    SingleBlob {
+        id: Id,
+    },
     /// Request searching for a block's parent. The id is the chain
-    ParentLookup { id: Id },
+    ParentLookup {
+        id: Id,
+    },
+    ParentLookupBlob {
+        id: Id,
+    },
     /// Request was from the backfill sync algorithm.
-    BackFillBlocks { id: Id },
+    BackFillBlocks {
+        id: Id,
+    },
     /// Backfill request that is composed by both a block range request and a blob range request.
-    BackFillBlockAndBlobs { id: Id },
+    BackFillBlockAndBlobs {
+        id: Id,
+    },
     /// The request was from a chain in the range sync algorithm.
-    RangeBlocks { id: Id },
+    RangeBlocks {
+        id: Id,
+    },
     /// Range request that is composed by both a block range request and a blob range request.
-    RangeBlockAndBlobs { id: Id },
+    RangeBlockAndBlobs {
+        id: Id,
+    },
 }
 
-// TODO(diva) I'm updating functions what at a time, but this should be revisited because I think
-// some code paths that are split for blobs and blocks can be made just one after sync as a whole
-// is updated.
-
 #[derive(Debug)]
 /// A message that can be sent to the sync manager thread.
 pub enum SyncMessage<T: EthSpec> {
@@ -174,6 +195,7 @@ pub enum SyncMessage<T: EthSpec> {
 #[derive(Debug, Clone)]
 pub enum BlockProcessType {
     SingleBlock { id: Id },
+    SingleBlob { id: Id },
     ParentLookup { chain_hash: Hash256 },
 }
 
@@ -324,16 +346,40 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         trace!(self.log, "Sync manager received a failed RPC");
         match request_id {
             RequestId::SingleBlock { id } => {
-                self.block_lookups.single_block_lookup_failed(
-                    id,
-                    &peer_id,
-                    &mut self.network,
-                    error,
-                );
+                self.block_lookups
+                    .single_block_lookup_failed::<BlockRequestState<Current>>(
+                        id,
+                        &peer_id,
+                        &mut self.network,
+                        error,
+                    );
+            }
+            RequestId::SingleBlob { id } => {
+                self.block_lookups
+                    .single_block_lookup_failed::<BlobRequestState<Current, T::EthSpec>>(
+                        id,
+                        &peer_id,
+                        &mut self.network,
+                        error,
+                    );
             }
             RequestId::ParentLookup { id } => {
                 self.block_lookups
-                    .parent_lookup_failed(id, peer_id, &mut self.network, error);
+                    .parent_lookup_failed::<BlockRequestState<Parent>>(
+                        id,
+                        peer_id,
+                        &mut self.network,
+                        error,
+                    );
+            }
+            RequestId::ParentLookupBlob { id } => {
+                self.block_lookups
+                    .parent_lookup_failed::<BlobRequestState<Parent, T::EthSpec>>(
+                        id,
+                        peer_id,
+                        &mut self.network,
+                        error,
+                    );
             }
             RequestId::BackFillBlocks { id } => {
                 if let Some(batch_id) = self
@@ -652,8 +698,11 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                 // If we are not synced, ignore this block.
                 if self.synced_and_connected(&peer_id) {
                     if self.should_delay_lookup(slot) {
-                        self.block_lookups
-                            .search_block_delayed(block_root, PeerShouldHave::Neither(peer_id));
+                        self.block_lookups.search_block_delayed(
+                            block_root,
+                            PeerShouldHave::Neither(peer_id),
+                            &self.network,
+                        );
                         if let Err(e) = self
                             .delayed_lookups
                             .try_send(DelayedLookupMessage::MissingComponents(block_root))
@@ -695,7 +744,18 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             } => match process_type {
                 BlockProcessType::SingleBlock { id } => self
                     .block_lookups
-                    .single_block_component_processed(id, result, response_type, &mut self.network),
+                    .single_block_component_processed::<BlockRequestState<Current>>(
+                        id,
+                        result,
+                        &self.network,
+                    ),
+                BlockProcessType::SingleBlob { id } => self
+                    .block_lookups
+                    .single_block_component_processed::<BlobRequestState<Current, T::EthSpec>>(
+                        id,
+                        result,
+                        &self.network,
+                    ),
                 BlockProcessType::ParentLookup { chain_hash } => self
                     .block_lookups
                     .parent_block_processed(chain_hash, result, response_type, &mut self.network),
@@ -753,6 +813,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     block_root,
                     parent_components,
                     &[PeerShouldHave::Neither(peer_id)],
+                    &self.network,
                 );
                 if let Err(e) = self
                     .delayed_lookups
@@ -883,20 +944,30 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         seen_timestamp: Duration,
     ) {
         match request_id {
-            RequestId::SingleBlock { id } => self.block_lookups.single_block_lookup_response(
-                id,
-                peer_id,
-                block,
-                seen_timestamp,
-                &mut self.network,
-            ),
-            RequestId::ParentLookup { id } => self.block_lookups.parent_lookup_response(
-                id,
-                peer_id,
-                block,
-                seen_timestamp,
-                &mut self.network,
-            ),
+            RequestId::SingleBlock { id } => self
+                .block_lookups
+                .single_lookup_response::<BlockRequestState<Current>>(
+                    id,
+                    peer_id,
+                    block,
+                    seen_timestamp,
+                    &self.network,
+                ),
+            RequestId::SingleBlob { id } => {
+                crit!(self.log, "Blob received during block request"; "peer_id" => %peer_id  );
+            }
+            RequestId::ParentLookup { id } => self
+                .block_lookups
+                .parent_lookup_response::<BlockRequestState<Parent>>(
+                    id,
+                    peer_id,
+                    block,
+                    seen_timestamp,
+                    &self.network,
+                ),
+            RequestId::ParentLookupBlob { id } => {
+                crit!(self.log, "Blob received during parent block request"; "peer_id" => %peer_id  );
+            }
             RequestId::BackFillBlocks { id } => {
                 let is_stream_terminator = block.is_none();
                 if let Some(batch_id) = self
@@ -954,20 +1025,31 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         seen_timestamp: Duration,
     ) {
         match request_id {
-            RequestId::SingleBlock { id } => self.block_lookups.single_blob_lookup_response(
-                id,
-                peer_id,
-                blob,
-                seen_timestamp,
-                &mut self.network,
-            ),
-            RequestId::ParentLookup { id } => self.block_lookups.parent_lookup_blob_response(
-                id,
-                peer_id,
-                blob,
-                seen_timestamp,
-                &mut self.network,
-            ),
+            RequestId::SingleBlock { id } => {
+                crit!(self.log, "Single blob received during block request"; "peer_id" => %peer_id  );
+            }
+            RequestId::SingleBlob { id } => self
+                .block_lookups
+                .single_lookup_response::<BlobRequestState<Current, T::EthSpec>>(
+                    id,
+                    peer_id,
+                    blob,
+                    seen_timestamp,
+                    &mut self.network,
+                ),
+
+            RequestId::ParentLookup { id } => {
+                crit!(self.log, "Single blob received during parent block request"; "peer_id" => %peer_id  );
+            }
+            RequestId::ParentLookupBlob { id } => self
+                .block_lookups
+                .parent_lookup_response::<BlobRequestState<Parent, T::EthSpec>>(
+                    id,
+                    peer_id,
+                    blob,
+                    seen_timestamp,
+                    &mut self.network,
+                ),
             RequestId::BackFillBlocks { id: _ } => {
                 crit!(self.log, "Blob received during backfill block request"; "peer_id" => %peer_id  );
             }
diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs
index d635dd2ea18..3524da78594 100644
--- a/beacon_node/network/src/sync/network_context.rs
+++ b/beacon_node/network/src/sync/network_context.rs
@@ -7,7 +7,7 @@ use super::range_sync::{BatchId, ByRangeRequestType, ChainId};
 use crate::network_beacon_processor::NetworkBeaconProcessor;
 use crate::service::{NetworkMessage, RequestId};
 use crate::status::ToStatusMessage;
-use crate::sync::block_lookups::{BlobRequestId, BlockRequestId};
+use crate::sync::block_lookups::LookupType;
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{BeaconChain, BeaconChainTypes, EngineState};
 use fnv::FnvHashMap;
@@ -37,7 +37,7 @@ pub struct SyncNetworkContext<T: BeaconChainTypes> {
     network_send: mpsc::UnboundedSender<NetworkMessage<T::EthSpec>>,
 
     /// A sequential ID for all RPC requests.
-    request_id: Id,
+    request_id: std::cell::Cell<Id>,
 
     /// BlocksByRange requests made by the range syncing algorithm.
     range_requests: FnvHashMap<Id, (ChainId, BatchId)>,
@@ -62,7 +62,7 @@ pub struct SyncNetworkContext<T: BeaconChainTypes> {
     pub chain: Arc<BeaconChain<T>>,
 
     /// Logger for the `SyncNetworkContext`.
-    log: slog::Logger,
+    pub log: slog::Logger,
 }
 
 /// Small enumeration to make dealing with block and blob requests easier.
@@ -93,7 +93,7 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         SyncNetworkContext {
             network_send,
             execution_engine_state: EngineState::Online, // always assume `Online` at the start
-            request_id: 1,
+            request_id: std::cell::Cell::new(1),
             range_requests: FnvHashMap::default(),
             backfill_requests: FnvHashMap::default(),
             range_blocks_and_blobs_requests: FnvHashMap::default(),
@@ -118,11 +118,7 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
             .unwrap_or_default()
     }
 
-    pub fn status_peers<C: ToStatusMessage>(
-        &mut self,
-        chain: &C,
-        peers: impl Iterator<Item = PeerId>,
-    ) {
+    pub fn status_peers<C: ToStatusMessage>(&self, chain: &C, peers: impl Iterator<Item = PeerId>) {
         let status_message = chain.status_message();
         for peer_id in peers {
             debug!(
@@ -409,70 +405,39 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
     }
 
     /// Sends a blocks by root request for a parent request.
-    pub fn single_block_lookup_request(
-        &mut self,
+    pub fn single_lookup_request(
+        &self,
+        id: Id,
         peer_id: PeerId,
         request: BlocksByRootRequest,
-    ) -> Result<Id, &'static str> {
-        let id = self.next_id();
-        let request_id = RequestId::Sync(SyncRequestId::SingleBlock { id });
-
-        trace!(
-            self.log,
-            "Sending BlocksByRoot Request";
-            "method" => "BlocksByRoot",
-            "count" => request.block_roots().len(),
-            "peer" => %peer_id
-        );
-
-        self.send_network_msg(NetworkMessage::SendRequest {
-            peer_id,
-            request: Request::BlocksByRoot(request),
-            request_id,
-        })?;
-        Ok(id)
+        blob_peer_id: PeerId,
+        blob_request: BlobsByRootRequest,
+        lookup_type: LookupType,
+    ) -> Result<(), &'static str> {
+        self.single_block_lookup_request_retry(id, peer_id, request, lookup_type)?;
+        self.single_blob_lookup_request_retry(id, blob_peer_id, blob_request, lookup_type)?;
+        Ok(())
     }
-
-    /// Sends a blobs by root request for a parent request.
-    pub fn single_blobs_lookup_request(
-        &mut self,
-        peer_id: PeerId,
-        request: BlobsByRootRequest,
-    ) -> Result<Id, &'static str> {
-        let id = self.next_id();
-        let request_id = RequestId::Sync(SyncRequestId::SingleBlock { id });
-
-        trace!(
-            self.log,
-            "Sending BlobsByRoot Request";
-            "method" => "BlobsByRoot",
-            "count" => request.blob_ids.len(),
-            "peer" => %peer_id
-        );
-
-        self.send_network_msg(NetworkMessage::SendRequest {
-            peer_id,
-            request: Request::BlobsByRoot(request),
-            request_id,
-        })?;
-        Ok(id)
-    }
-
-    /// Sends a blocks by root request for a parent request.
-    pub fn parent_lookup_block_request(
-        &mut self,
+    pub fn single_block_lookup_request_retry(
+        &self,
+        id: Id,
         peer_id: PeerId,
         request: BlocksByRootRequest,
-    ) -> Result<BlockRequestId, &'static str> {
-        let id = self.next_id();
-        let request_id = RequestId::Sync(SyncRequestId::ParentLookup { id });
+        lookup_type: LookupType,
+    ) -> Result<(), &'static str> {
+        let sync_id = match lookup_type {
+            LookupType::Current => SyncRequestId::SingleBlock { id },
+            LookupType::Parent => SyncRequestId::ParentLookup { id },
+        };
+        let request_id = RequestId::Sync(sync_id);
 
         trace!(
             self.log,
-            "Sending parent BlocksByRoot Request";
+            "Sending BlocksByRoot Request";
             "method" => "BlocksByRoot",
             "count" => request.block_roots().len(),
-            "peer" => %peer_id
+            "peer" => %peer_id,
+            "lookup_type" => ?lookup_type
         );
 
         self.send_network_msg(NetworkMessage::SendRequest {
@@ -480,32 +445,34 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
             request: Request::BlocksByRoot(request),
             request_id,
         })?;
-        Ok(id)
+        Ok(())
     }
 
-    /// Sends a blocks by root request for a parent request.
-    pub fn parent_lookup_blobs_request(
-        &mut self,
-        peer_id: PeerId,
-        request: BlobsByRootRequest,
-    ) -> Result<BlobRequestId, &'static str> {
-        let id = self.next_id();
-        let request_id = RequestId::Sync(SyncRequestId::ParentLookup { id });
-
-        trace!(
-            self.log,
-            "Sending parent BlobsByRoot Request";
-            "method" => "BlobsByRoot",
-            "count" => request.blob_ids.len(),
-            "peer" => %peer_id
-        );
+    pub fn single_blob_lookup_request_retry(
+        &self,
+        id: Id,
+        blob_peer_id: PeerId,
+        blob_request: BlobsByRootRequest,
+        lookup_type: LookupType,
+    ) -> Result<(), &'static str> {
+        let request_id = RequestId::Sync(SyncRequestId::SingleBlob { id });
+
+        if !blob_request.blob_ids.is_empty() {
+            trace!(
+                self.log,
+                "Sending BlobsByRoot Request";
+                "method" => "BlobsByRoot",
+                "count" => blob_request.blob_ids.len(),
+                "peer" => %blob_peer_id
+            );
 
-        self.send_network_msg(NetworkMessage::SendRequest {
-            peer_id,
-            request: Request::BlobsByRoot(request),
-            request_id,
-        })?;
-        Ok(id)
+            self.send_network_msg(NetworkMessage::SendRequest {
+                peer_id: blob_peer_id,
+                request: Request::BlobsByRoot(blob_request),
+                request_id,
+            })?;
+        }
+        Ok(())
     }
 
     pub fn is_execution_engine_online(&self) -> bool {
@@ -532,7 +499,7 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
     }
 
     /// Reports to the scoring algorithm the behaviour of a peer.
-    pub fn report_peer(&mut self, peer_id: PeerId, action: PeerAction, msg: &'static str) {
+    pub fn report_peer(&self, peer_id: PeerId, action: PeerAction, msg: &'static str) {
         debug!(self.log, "Sync reporting peer"; "peer_id" => %peer_id, "action" => %action);
         self.network_send
             .send(NetworkMessage::ReportPeer {
@@ -547,7 +514,7 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
     }
 
     /// Subscribes to core topics.
-    pub fn subscribe_core_topics(&mut self) {
+    pub fn subscribe_core_topics(&self) {
         self.network_send
             .send(NetworkMessage::SubscribeCoreTopics)
             .unwrap_or_else(|e| {
@@ -556,7 +523,7 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
     }
 
     /// Sends an arbitrary network message.
-    fn send_network_msg(&mut self, msg: NetworkMessage<T::EthSpec>) -> Result<(), &'static str> {
+    fn send_network_msg(&self, msg: NetworkMessage<T::EthSpec>) -> Result<(), &'static str> {
         self.network_send.send(msg).map_err(|_| {
             debug!(self.log, "Could not send message to the network service");
             "Network channel send Failed"
@@ -572,10 +539,10 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         &self.network_beacon_processor
     }
 
-    fn next_id(&mut self) -> Id {
-        let id = self.request_id;
-        self.request_id += 1;
-        id
+    pub fn next_id(&self) -> Id {
+        let current_value = self.request_id.get();
+        self.request_id.set(current_value + 1);
+        current_value
     }
 
     /// Check whether a batch for this epoch (and only this epoch) should request just blocks or
@@ -587,25 +554,17 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         const _: () = assert!(
             super::backfill_sync::BACKFILL_EPOCHS_PER_BATCH == 1
                 && super::range_sync::EPOCHS_PER_BATCH == 1,
-            "To deal with alignment with 4844 boundaries, batches need to be of just one epoch"
+            "To deal with alignment with deneb boundaries, batches need to be of just one epoch"
         );
 
-        #[cfg(test)]
-        {
-            // Keep tests only for blocks.
-            ByRangeRequestType::Blocks
-        }
-        #[cfg(not(test))]
-        {
-            if let Some(data_availability_boundary) = self.chain.data_availability_boundary() {
-                if epoch >= data_availability_boundary {
-                    ByRangeRequestType::BlocksAndBlobs
-                } else {
-                    ByRangeRequestType::Blocks
-                }
+        if let Some(data_availability_boundary) = self.chain.data_availability_boundary() {
+            if epoch >= data_availability_boundary {
+                ByRangeRequestType::BlocksAndBlobs
             } else {
                 ByRangeRequestType::Blocks
             }
+        } else {
+            ByRangeRequestType::Blocks
         }
     }
 }

From e27161ed2171e34527d17cb8067c0a16a684e132 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Tue, 25 Jul 2023 16:18:59 -0400
Subject: [PATCH 05/18] get tests compiling

---
 .../network_beacon_processor/sync_methods.rs  |   4 -
 .../network/src/sync/block_lookups/mod.rs     |  71 +--
 .../src/sync/block_lookups/parent_lookup.rs   |  20 +-
 .../sync/block_lookups/single_block_lookup.rs | 114 ++---
 .../network/src/sync/block_lookups/tests.rs   | 422 +++++++++++-------
 beacon_node/network/src/sync/manager.rs       |  40 +-
 .../network/src/sync/network_context.rs       |  17 +-
 7 files changed, 385 insertions(+), 303 deletions(-)

diff --git a/beacon_node/network/src/network_beacon_processor/sync_methods.rs b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
index b21bc6abde8..a1176bebbca 100644
--- a/beacon_node/network/src/network_beacon_processor/sync_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/sync_methods.rs
@@ -1,6 +1,5 @@
 use crate::metrics;
 use crate::network_beacon_processor::{NetworkBeaconProcessor, FUTURE_SLOT_TOLERANCE};
-use crate::sync::manager::ResponseType;
 use crate::sync::BatchProcessResult;
 use crate::sync::{
     manager::{BlockProcessType, SyncMessage},
@@ -96,7 +95,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             self.send_sync_message(SyncMessage::BlockComponentProcessed {
                 process_type,
                 result: crate::sync::manager::BlockProcessingResult::Ignored,
-                response_type: crate::sync::manager::ResponseType::Block,
             });
         };
         (process_fn, Box::new(ignore_fn))
@@ -251,7 +249,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         self.send_sync_message(SyncMessage::BlockComponentProcessed {
             process_type,
             result: result.into(),
-            response_type: ResponseType::Block,
         });
 
         // Drop the handle to remove the entry from the cache
@@ -303,7 +300,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         self.send_sync_message(SyncMessage::BlockComponentProcessed {
             process_type,
             result: result.into(),
-            response_type: ResponseType::Blob,
         });
     }
 
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index d9184cee594..79ef277468f 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -5,7 +5,9 @@ use super::BatchProcessResult;
 use super::{manager::BlockProcessType, network_context::SyncNetworkContext};
 use crate::metrics;
 use crate::network_beacon_processor::ChainSegmentProcessId;
-use crate::sync::block_lookups::single_block_lookup::LookupId;
+use crate::sync::block_lookups::parent_lookup::ParentLookup;
+use crate::sync::block_lookups::single_block_lookup::LookupVerifyError;
+use crate::sync::manager::{Id, ResponseType};
 use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
 use beacon_chain::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
 use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
@@ -26,7 +28,7 @@ use std::time::Duration;
 use store::{Hash256, SignedBeaconBlock};
 use strum::Display;
 use types::blob_sidecar::FixedBlobSidecarList;
-use types::{BlobSidecar, EthSpec, Slot};
+use types::Slot;
 
 pub(crate) mod delayed_lookup;
 mod parent_lookup;
@@ -116,7 +118,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         &mut self,
         block_root: Hash256,
         peer_source: PeerShouldHave,
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
         let lookup = self.new_current_lookup(block_root, None, &[peer_source], cx);
         if let Some(lookup) = lookup {
@@ -131,7 +133,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         &mut self,
         block_root: Hash256,
         peer_source: PeerShouldHave,
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
         let lookup = self.new_current_lookup(block_root, None, &[peer_source], cx);
         if let Some(lookup) = lookup {
@@ -150,7 +152,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block_root: Hash256,
         parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
         let lookup = self.new_current_lookup(block_root, parent_components, peer_source, cx);
         if let Some(lookup) = lookup {
@@ -170,7 +172,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block_root: Hash256,
         parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
         let lookup = self.new_current_lookup(block_root, parent_components, peer_source, cx);
         if let Some(lookup) = lookup {
@@ -207,10 +209,11 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         cx: &SyncNetworkContext<T>,
     ) -> Result<(), ()> {
         for (_, lookup) in self.single_block_lookups.iter_mut() {
-            if lookup.block_request_state.requested_block_root == block_root && !lookup.triggered {
-                if lookup.request_block_and_blobs(cx).is_ok() {
-                    lookup.triggered = true;
-                }
+            if lookup.block_request_state.requested_block_root == block_root
+                && !lookup.triggered
+                && lookup.request_block_and_blobs(cx).is_ok()
+            {
+                lookup.triggered = true;
             }
         }
         Ok(())
@@ -228,13 +231,13 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block_root: Hash256,
         parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) -> Option<SingleBlockLookup<Current, T>> {
         // Do not re-request a block that is already being requested
         if let Some((_, lookup)) = self
             .single_block_lookups
             .iter_mut()
-            .find(|(id, lookup)| lookup.is_for_block(block_root))
+            .find(|(_id, lookup)| lookup.is_for_block(block_root))
         {
             lookup.add_peers(peers);
             if let Some(components) = parent_components {
@@ -274,7 +277,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             parent_components,
             peers,
             self.da_checker.clone(),
-            cx,
+            cx.next_id(),
         ))
     }
 
@@ -286,7 +289,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         block_root: Hash256,
         parent_root: Hash256,
         peer_id: PeerId,
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
         // Gossip blocks or blobs shouldn't be propagated if parents are unavailable.
         let peer_source = PeerShouldHave::BlockAndBlobs(peer_id);
@@ -383,17 +386,15 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                             }
                         }
                     }
-                } else {
-                    if let Err(()) = R::send_for_processing(
-                        id,
-                        self,
-                        root,
-                        R::verified_to_reconstructed(verified_response),
-                        seen_timestamp,
-                        &cx,
-                    ) {
-                        self.single_block_lookups.remove(&id);
-                    }
+                } else if let Err(()) = R::send_for_processing(
+                    id,
+                    self,
+                    root,
+                    R::verified_to_reconstructed(verified_response),
+                    seen_timestamp,
+                    cx,
+                ) {
+                    self.single_block_lookups.remove(&id);
                 }
             }
             Ok(None) => {}
@@ -616,7 +617,13 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         let request_state = R::request_state_mut(lookup);
         request_state.register_failure_downloading();
         let response_type = R::response_type();
-        trace!(self.log, "Single lookup failed"; "block_root" => ?root, "error" => msg, "response_type" => ?response_type);
+        trace!(self.log,
+            "Single lookup failed";
+            "block_root" => ?root,
+            "error" => msg,
+            "peer_id" => %peer_id,
+            "response_type" => ?response_type
+        );
         if let Err(()) = request_state.retry_request_after_failure(id, cx, &self.log) {
             self.single_block_lookups.remove(&id);
         };
@@ -633,7 +640,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         &mut self,
         target_id: Id,
         result: BlockProcessingResult<T::EthSpec>,
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
         let Some(request_ref) = self.single_block_lookups.get_mut(&target_id) else {
            debug!(self.log, "Block component processed for single block lookup not present"    );
@@ -793,8 +800,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         &mut self,
         chain_hash: Hash256,
         result: BlockProcessingResult<T::EthSpec>,
-        response_type: ResponseType,
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) {
         let index = self
             .parent_lookups
@@ -865,7 +871,8 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 // to send for processing.
                 if let Some(child_lookup_id) =
                     self.single_block_lookups.iter().find_map(|(id, lookup)| {
-                        (lookup.block_request_state.requested_block_root == chain_hash).then(|| *id)
+                        (lookup.block_request_state.requested_block_root == chain_hash)
+                            .then_some(*id)
                     })
                 {
                     let Some(child_lookup) = self.single_block_lookups.get_mut(&child_lookup_id)  else {
@@ -972,7 +979,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     .single_block_lookups
                     .iter()
                     .find_map(|(id, req)|
-                        (req.block_request_state.requested_block_root == chain_hash).then(|| *id)) else {
+                        (req.block_request_state.requested_block_root == chain_hash).then_some(*id)) else {
                     warn!(self.log, "No id found for single block lookup"; "chain_hash" => %chain_hash);
                     return;
                 };
@@ -991,7 +998,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                             chain_hash,
                             rpc_block,
                             Duration::from_secs(0), //TODO(sean) pipe this through
-                            BlockProcessType::SingleBlock { id: id },
+                            BlockProcessType::SingleBlock { id },
                             cx,
                         )
                         .is_err()
diff --git a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
index 1df51bf7f06..6afeaccc7b7 100644
--- a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
@@ -3,7 +3,6 @@ use super::{DownloadedBlocks, PeerShouldHave};
 use crate::sync::block_lookups::single_block_lookup::{
     Parent, RequestState, State, UnknownParentComponents,
 };
-use crate::sync::block_lookups::Lookup;
 use crate::sync::{manager::SLOT_IMPORT_TOLERANCE, network_context::SyncNetworkContext};
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::block_verification_types::RpcBlock;
@@ -14,8 +13,6 @@ use lighthouse_network::PeerId;
 use std::sync::Arc;
 use store::Hash256;
 use strum::IntoStaticStr;
-use types::blob_sidecar::FixedBlobSidecarList;
-use types::SignedBeaconBlock;
 
 /// How many attempts we try to find a parent of a block before we give up trying.
 pub(crate) const PARENT_FAIL_TOLERANCE: u8 = 5;
@@ -67,14 +64,14 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         parent_root: Hash256,
         peer_id: PeerShouldHave,
         da_checker: Arc<DataAvailabilityChecker<T>>,
-        cx: &SyncNetworkContext<T>,
+        cx: &mut SyncNetworkContext<T>,
     ) -> Self {
         let current_parent_request = SingleBlockLookup::new(
             parent_root,
             Some(<_>::default()),
             &[peer_id],
             da_checker,
-            cx,
+            cx.next_id(),
         );
 
         Self {
@@ -144,16 +141,6 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
             Some(UnknownParentComponents::default());
     }
 
-    pub fn add_current_request_block(&mut self, block: Arc<SignedBeaconBlock<T::EthSpec>>) {
-        // Cache the block.
-        self.current_parent_request.add_unknown_parent_block(block);
-    }
-
-    pub fn add_current_request_blobs(&mut self, blobs: FixedBlobSidecarList<T::EthSpec>) {
-        // Cache the blobs.
-        self.current_parent_request.add_unknown_parent_blobs(blobs);
-    }
-
     pub fn processing_peer(&self) -> Result<PeerShouldHave, ()> {
         self.current_parent_request
             .block_request_state
@@ -234,8 +221,7 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         // be dropped and the peer downscored.
         if let Some(parent_root) = root_and_block
             .as_ref()
-            .map(|(_, block)| R::get_parent_root(block))
-            .flatten()
+            .and_then(|(_, block)| R::get_parent_root(block))
         {
             if failed_chains.contains(&parent_root) {
                 request_state.register_failure_downloading();
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index e6e1e72e72f..5499c669864 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -1,5 +1,4 @@
 use super::{PeerShouldHave, ResponseType};
-use crate::sync::block_lookups::parent_lookup::RequestError::SendFailed;
 use crate::sync::block_lookups::parent_lookup::PARENT_FAIL_TOLERANCE;
 use crate::sync::block_lookups::{
     BlockLookups, Id, LookupType, RootBlobsTuple, RootBlockTuple, SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS,
@@ -9,7 +8,6 @@ use crate::sync::network_context::SyncNetworkContext;
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::data_availability_checker::DataAvailabilityChecker;
 use beacon_chain::{get_block_root, BeaconChainTypes};
-use itertools::Itertools;
 use lighthouse_network::rpc::methods::BlobsByRootRequest;
 use lighthouse_network::{rpc::BlocksByRootRequest, PeerId};
 use rand::seq::IteratorRandom;
@@ -95,9 +93,6 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
     fn processing_peer(&self) -> Result<PeerShouldHave, ()> {
         self.get_state().processing_peer()
     }
-    fn downloading_peer(&self) -> Result<PeerShouldHave, ()> {
-        self.get_state().peer()
-    }
     fn set_component_processed(&mut self) {
         self.get_state_mut().component_processed = true;
     }
@@ -185,7 +180,7 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
         request_state.failed_processing >= request_state.failed_downloading
     }
     fn get_peer(&mut self) -> Result<PeerId, LookupRequestError> {
-        let mut request_state = self.get_state_mut();
+        let request_state = self.get_state_mut();
         let Some(peer_id) =         request_state
             .available_peers
             .iter()
@@ -441,7 +436,7 @@ impl<L: Lookup, T: EthSpec> BlobRequestState<L, T> {
             requested_ids: <_>::default(),
             blob_download_queue: <_>::default(),
             state: SingleLookupRequestState::new(peer_source),
-            _phantom: PhantomData::default(),
+            _phantom: PhantomData,
         }
     }
 }
@@ -457,7 +452,7 @@ impl<L: Lookup> BlockRequestState<L> {
         Self {
             requested_block_root: block_root,
             state: SingleLookupRequestState::new(peers),
-            _phantom: PhantomData::default(),
+            _phantom: PhantomData,
         }
     }
 }
@@ -585,10 +580,10 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
         unknown_parent_components: Option<UnknownParentComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
         da_checker: Arc<DataAvailabilityChecker<T>>,
-        cx: &SyncNetworkContext<T>,
+        id: Id,
     ) -> Self {
         Self {
-            id: cx.next_id(),
+            id,
             block_request_state: BlockRequestState::new(requested_block_root, peers),
             blob_request_state: BlobRequestState::new(peers),
             da_checker,
@@ -732,27 +727,6 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
             self.unknown_parent_components = Some(components);
         }
     }
-    pub fn add_unknown_parent_block(&mut self, block: Arc<SignedBeaconBlock<T::EthSpec>>) {
-        if let Some(ref mut components) = self.unknown_parent_components {
-            components.add_unknown_parent_block(block)
-        } else {
-            self.unknown_parent_components = Some(UnknownParentComponents {
-                downloaded_block: Some(block),
-                downloaded_blobs: FixedBlobSidecarList::default(),
-            })
-        }
-    }
-
-    pub fn add_unknown_parent_blobs(&mut self, blobs: FixedBlobSidecarList<T::EthSpec>) {
-        if let Some(ref mut components) = self.unknown_parent_components {
-            components.add_unknown_parent_blobs(blobs)
-        } else {
-            self.unknown_parent_components = Some(UnknownParentComponents {
-                downloaded_block: None,
-                downloaded_blobs: blobs,
-            })
-        }
-    }
 
     pub fn add_peers(&mut self, peers: &[PeerShouldHave]) {
         for peer in peers {
@@ -886,14 +860,6 @@ impl SingleLookupRequestState {
         }
     }
 
-    pub fn peer(&self) -> Result<PeerShouldHave, ()> {
-        match &self.state {
-            State::Processing { peer_id } => Ok(*peer_id),
-            State::Downloading { peer_id } => Ok(*peer_id),
-            _ => Err(()),
-        }
-    }
-
     pub fn remove_peer_if_useless(&mut self, peer_id: &PeerId) {
         if !self.available_peers.is_empty() || self.potential_peers.len() > 1 {
             self.potential_peers.remove(peer_id);
@@ -981,6 +947,26 @@ mod tests {
     }
     type T = Witness<TestingSlotClock, CachingEth1Backend<E>, E, MemoryStore<E>, MemoryStore<E>>;
 
+    struct TestLookup1;
+
+    impl Lookup for TestLookup1 {
+        const MAX_ATTEMPTS: u8 = 3;
+
+        fn lookup_type() -> LookupType {
+            panic!()
+        }
+    }
+
+    struct TestLookup2;
+
+    impl Lookup for TestLookup2 {
+        const MAX_ATTEMPTS: u8 = 4;
+
+        fn lookup_type() -> LookupType {
+            panic!()
+        }
+    }
+
     #[test]
     fn test_happy_path() {
         let peer_id = PeerShouldHave::BlockAndBlobs(PeerId::random());
@@ -998,15 +984,28 @@ mod tests {
             DataAvailabilityChecker::new(slot_clock, None, store.into(), spec)
                 .expect("data availability checker"),
         );
-        let mut sl =
-            SingleBlockLookup::<4, T>::new(block.canonical_root(), None, &[peer_id], da_checker);
-        sl.request_block().unwrap();
-        sl.verify_block(Some(block.into())).unwrap().unwrap();
+        let mut sl = SingleBlockLookup::<TestLookup1, T>::new(
+            block.canonical_root(),
+            None,
+            &[peer_id],
+            da_checker,
+            1,
+        );
+        <BlockRequestState<TestLookup1> as RequestState<TestLookup1, T>>::build_request(
+            &mut sl.block_request_state,
+        )
+        .unwrap();
+        <BlockRequestState<TestLookup1> as RequestState<TestLookup1, T>>::verify_response(
+            &mut sl.block_request_state,
+            block.canonical_root(),
+            Some(block.into()),
+        )
+        .unwrap()
+        .unwrap();
     }
 
     #[test]
     fn test_block_lookup_failures() {
-        const FAILURES: u8 = 3;
         let peer_id = PeerShouldHave::BlockAndBlobs(PeerId::random());
         let block = rand_block();
         let spec = E::default_spec();
@@ -1024,25 +1023,40 @@ mod tests {
                 .expect("data availability checker"),
         );
 
-        let mut sl = SingleBlockLookup::<FAILURES, T>::new(
+        let mut sl = SingleBlockLookup::<TestLookup2, T>::new(
             block.canonical_root(),
             None,
             &[peer_id],
             da_checker,
+            1,
         );
-        for _ in 1..FAILURES {
-            sl.request_block().unwrap();
+        for _ in 1..TestLookup2::MAX_ATTEMPTS {
+            <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::build_request(
+                &mut sl.block_request_state,
+            )
+            .unwrap();
             sl.block_request_state.state.register_failure_downloading();
         }
 
         // Now we receive the block and send it for processing
-        sl.request_block().unwrap();
-        sl.verify_block(Some(block.into())).unwrap().unwrap();
+        <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::build_request(
+            &mut sl.block_request_state,
+        )
+        .unwrap();
+        <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::verify_response(
+            &mut sl.block_request_state,
+            block.canonical_root(),
+            Some(block.into()),
+        )
+        .unwrap()
+        .unwrap();
 
         // One processing failure maxes the available attempts
         sl.block_request_state.state.register_failure_processing();
         assert_eq!(
-            sl.request_block(),
+            <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::build_request(
+                &mut sl.block_request_state
+            ),
             Err(LookupRequestError::TooManyAttempts {
                 cannot_process: false
             })
diff --git a/beacon_node/network/src/sync/block_lookups/tests.rs b/beacon_node/network/src/sync/block_lookups/tests.rs
index c12f101a3ec..d7c9688e502 100644
--- a/beacon_node/network/src/sync/block_lookups/tests.rs
+++ b/beacon_node/network/src/sync/block_lookups/tests.rs
@@ -20,7 +20,8 @@ use tokio::sync::mpsc;
 use types::{
     map_fork_name, map_fork_name_with,
     test_utils::{SeedableRng, TestRandom, XorShiftRng},
-    BeaconBlock, EthSpec, ForkName, FullPayloadDeneb, MinimalEthSpec as E, SignedBeaconBlock,
+    BeaconBlock, BlobSidecar, EthSpec, ForkName, FullPayloadDeneb, MinimalEthSpec as E,
+    SignedBeaconBlock,
 };
 
 type T = Witness<ManualSlotClock, CachingEth1Backend<E>, E, MemoryStore<E>, MemoryStore<E>>;
@@ -304,7 +305,13 @@ fn test_single_block_lookup_happy_path() {
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_lookup_response(id, peer_id, Some(block.into()), D, &mut cx);
+    bl.single_lookup_response::<BlockRequestState<Current>>(
+        id,
+        peer_id,
+        Some(block.into()),
+        D,
+        &cx,
+    );
     rig.expect_empty_network();
     rig.expect_block_process(response_type);
 
@@ -313,11 +320,10 @@ fn test_single_block_lookup_happy_path() {
 
     // Send the stream termination. Peer should have not been penalized, and the request removed
     // after processing.
-    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
-    bl.single_block_component_processed(
+    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
+    bl.single_block_component_processed::<BlockRequestState<Current>>(
         id,
         BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        response_type,
         &mut cx,
     );
     rig.expect_empty_network();
@@ -346,7 +352,7 @@ fn test_single_block_lookup_empty_response() {
     }
 
     // The peer does not have the block. It should be penalized.
-    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
+    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
     rig.expect_penalty();
 
     rig.expect_block_request(response_type); // it should be retried
@@ -375,12 +381,18 @@ fn test_single_block_lookup_wrong_response() {
 
     // Peer sends something else. It should be penalized.
     let bad_block = rig.rand_block(fork_name);
-    bl.single_lookup_response(id, peer_id, Some(bad_block.into()), D, &mut cx);
+    bl.single_lookup_response::<BlockRequestState<Current>>(
+        id,
+        peer_id,
+        Some(bad_block.into()),
+        D,
+        &cx,
+    );
     rig.expect_penalty();
     rig.expect_block_request(response_type); // should be retried
 
     // Send the stream termination. This should not produce an additional penalty.
-    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
+    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
     rig.expect_empty_network();
 }
 
@@ -406,7 +418,12 @@ fn test_single_block_lookup_failure() {
     }
 
     // The request fails. RPC failures are handled elsewhere so we should not penalize the peer.
-    bl.single_block_lookup_failed(id, &peer_id, &mut cx, RPCError::UnsupportedProtocol);
+    bl.single_block_lookup_failed::<BlockRequestState<Current>>(
+        id,
+        &peer_id,
+        &cx,
+        RPCError::UnsupportedProtocol,
+    );
     rig.expect_block_request(response_type);
     rig.expect_empty_network();
 }
@@ -438,7 +455,13 @@ fn test_single_block_lookup_becomes_parent_request() {
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_lookup_response(id, peer_id, Some(block.clone()), D, &mut cx);
+    bl.single_lookup_response::<BlockRequestState<Current>>(
+        id,
+        peer_id,
+        Some(block.clone()),
+        D,
+        &cx,
+    );
     rig.expect_empty_network();
     rig.expect_block_process(response_type);
 
@@ -447,10 +470,9 @@ fn test_single_block_lookup_becomes_parent_request() {
 
     // Send the stream termination. Peer should have not been penalized, and the request moved to a
     // parent request after processing.
-    bl.single_block_component_processed(
+    bl.single_block_component_processed::<BlockRequestState<Current>>(
         id,
         BlockError::ParentUnknown(block.into()).into(),
-        response_type,
         &mut cx,
     );
     assert_eq!(bl.single_block_lookups.len(), 1);
@@ -491,22 +513,23 @@ fn test_parent_lookup_happy_path() {
     }
 
     // Peer sends the right block, it should be sent for processing. Peer should not be penalized.
-    bl.parent_lookup_response(id, peer_id, Some(parent.into()), D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(
+        id,
+        peer_id,
+        Some(parent.into()),
+        D,
+        &cx,
+    );
     rig.expect_block_process(response_type);
     rig.expect_empty_network();
 
     // Processing succeeds, now the rest of the chain should be sent for processing.
-    bl.parent_block_processed(
-        chain_hash,
-        BlockError::BlockIsAlreadyKnown.into(),
-        response_type,
-        &mut cx,
-    );
+    bl.parent_block_processed(chain_hash, BlockError::BlockIsAlreadyKnown.into(), &mut cx);
     rig.expect_parent_chain_process();
     let process_result = BatchProcessResult::Success {
         was_non_empty: true,
     };
-    bl.parent_chain_processed(chain_hash, process_result, &mut cx);
+    bl.parent_chain_processed(chain_hash, process_result, &cx);
     assert_eq!(bl.parent_lookups.len(), 0);
 }
 
@@ -538,30 +561,41 @@ fn test_parent_lookup_wrong_response() {
 
     // Peer sends the wrong block, peer should be penalized and the block re-requested.
     let bad_block = rig.rand_block(fork_name);
-    bl.parent_lookup_response(id1, peer_id, Some(bad_block.into()), D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(
+        id1,
+        peer_id,
+        Some(bad_block.into()),
+        D,
+        &cx,
+    );
     rig.expect_penalty();
     let id2 = rig.expect_parent_request(response_type);
 
     // Send the stream termination for the first request. This should not produce extra penalties.
-    bl.parent_lookup_response(id1, peer_id, None, D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(id1, peer_id, None, D, &cx);
     rig.expect_empty_network();
 
     // Send the right block this time.
-    bl.parent_lookup_response(id2, peer_id, Some(parent.into()), D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(
+        id2,
+        peer_id,
+        Some(parent.into()),
+        D,
+        &cx,
+    );
     rig.expect_block_process(response_type);
 
     // Processing succeeds, now the rest of the chain should be sent for processing.
     bl.parent_block_processed(
         chain_hash,
         BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        response_type,
         &mut cx,
     );
     rig.expect_parent_chain_process();
     let process_result = BatchProcessResult::Success {
         was_non_empty: true,
     };
-    bl.parent_chain_processed(chain_hash, process_result, &mut cx);
+    bl.parent_chain_processed(chain_hash, process_result, &cx);
     assert_eq!(bl.parent_lookups.len(), 0);
 }
 
@@ -592,26 +626,31 @@ fn test_parent_lookup_empty_response() {
     }
 
     // Peer sends an empty response, peer should be penalized and the block re-requested.
-    bl.parent_lookup_response(id1, peer_id, None, D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(id1, peer_id, None, D, &cx);
     rig.expect_penalty();
     let id2 = rig.expect_parent_request(response_type);
 
     // Send the right block this time.
-    bl.parent_lookup_response(id2, peer_id, Some(parent.into()), D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(
+        id2,
+        peer_id,
+        Some(parent.into()),
+        D,
+        &cx,
+    );
     rig.expect_block_process(response_type);
 
     // Processing succeeds, now the rest of the chain should be sent for processing.
     bl.parent_block_processed(
         chain_hash,
         BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        response_type,
         &mut cx,
     );
     rig.expect_parent_chain_process();
     let process_result = BatchProcessResult::Success {
         was_non_empty: true,
     };
-    bl.parent_chain_processed(chain_hash, process_result, &mut cx);
+    bl.parent_chain_processed(chain_hash, process_result, &cx);
     assert_eq!(bl.parent_lookups.len(), 0);
 }
 
@@ -642,10 +681,10 @@ fn test_parent_lookup_rpc_failure() {
     }
 
     // The request fails. It should be tried again.
-    bl.parent_lookup_failed(
+    bl.parent_lookup_failed::<BlockRequestState<Parent>>(
         id1,
         peer_id,
-        &mut cx,
+        &cx,
         RPCError::ErrorResponse(
             RPCResponseErrorCode::ResourceUnavailable,
             "older than deneb".into(),
@@ -654,21 +693,26 @@ fn test_parent_lookup_rpc_failure() {
     let id2 = rig.expect_parent_request(response_type);
 
     // Send the right block this time.
-    bl.parent_lookup_response(id2, peer_id, Some(parent.into()), D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(
+        id2,
+        peer_id,
+        Some(parent.into()),
+        D,
+        &cx,
+    );
     rig.expect_block_process(response_type);
 
     // Processing succeeds, now the rest of the chain should be sent for processing.
     bl.parent_block_processed(
         chain_hash,
         BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
-        response_type,
         &mut cx,
     );
     rig.expect_parent_chain_process();
     let process_result = BatchProcessResult::Success {
         was_non_empty: true,
     };
-    bl.parent_chain_processed(chain_hash, process_result, &mut cx);
+    bl.parent_chain_processed(chain_hash, process_result, &cx);
     assert_eq!(bl.parent_lookups.len(), 0);
 }
 
@@ -701,10 +745,10 @@ fn test_parent_lookup_too_many_attempts() {
             // make sure every error is accounted for
             0 => {
                 // The request fails. It should be tried again.
-                bl.parent_lookup_failed(
+                bl.parent_lookup_failed::<BlockRequestState<Parent>>(
                     id,
                     peer_id,
-                    &mut cx,
+                    &cx,
                     RPCError::ErrorResponse(
                         RPCResponseErrorCode::ResourceUnavailable,
                         "older than deneb".into(),
@@ -714,9 +758,15 @@ fn test_parent_lookup_too_many_attempts() {
             _ => {
                 // Send a bad block this time. It should be tried again.
                 let bad_block = rig.rand_block(fork_name);
-                bl.parent_lookup_response(id, peer_id, Some(bad_block.into()), D, &mut cx);
+                bl.parent_lookup_response::<BlockRequestState<Parent>>(
+                    id,
+                    peer_id,
+                    Some(bad_block.into()),
+                    D,
+                    &cx,
+                );
                 // Send the stream termination
-                bl.parent_lookup_response(id, peer_id, None, D, &mut cx);
+                bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
                 rig.expect_penalty();
             }
         }
@@ -764,10 +814,10 @@ fn test_parent_lookup_too_many_download_attempts_no_blacklist() {
         }
         if i % 2 != 0 {
             // The request fails. It should be tried again.
-            bl.parent_lookup_failed(
+            bl.parent_lookup_failed::<BlockRequestState<Parent>>(
                 id,
                 peer_id,
-                &mut cx,
+                &cx,
                 RPCError::ErrorResponse(
                     RPCResponseErrorCode::ResourceUnavailable,
                     "older than deneb".into(),
@@ -776,7 +826,13 @@ fn test_parent_lookup_too_many_download_attempts_no_blacklist() {
         } else {
             // Send a bad block this time. It should be tried again.
             let bad_block = rig.rand_block(fork_name);
-            bl.parent_lookup_response(id, peer_id, Some(bad_block.into()), D, &mut cx);
+            bl.parent_lookup_response::<BlockRequestState<Parent>>(
+                id,
+                peer_id,
+                Some(bad_block.into()),
+                D,
+                &cx,
+            );
             rig.expect_penalty();
         }
         if i < parent_lookup::PARENT_FAIL_TOLERANCE {
@@ -825,10 +881,10 @@ fn test_parent_lookup_too_many_processing_attempts_must_blacklist() {
             let _ = rig.expect_parent_request(ResponseType::Blob);
         }
         // The request fails. It should be tried again.
-        bl.parent_lookup_failed(
+        bl.parent_lookup_failed::<BlockRequestState<Parent>>(
             id,
             peer_id,
-            &mut cx,
+            &cx,
             RPCError::ErrorResponse(
                 RPCResponseErrorCode::ResourceUnavailable,
                 "older than deneb".into(),
@@ -846,14 +902,15 @@ fn test_parent_lookup_too_many_processing_attempts_must_blacklist() {
         // we don't require a response because we're generateing 0-blob blocks in this test.
         assert!(!bl.failed_chains.contains(&block_root));
         // send the right parent but fail processing
-        bl.parent_lookup_response(id, peer_id, Some(parent.clone()), D, &mut cx);
-        bl.parent_block_processed(
-            block_root,
-            BlockError::InvalidSignature.into(),
-            response_type,
-            &mut cx,
+        bl.parent_lookup_response::<BlockRequestState<Parent>>(
+            id,
+            peer_id,
+            Some(parent.clone()),
+            D,
+            &cx,
         );
-        bl.parent_lookup_response(id, peer_id, None, D, &mut cx);
+        bl.parent_block_processed(block_root, BlockError::InvalidSignature.into(), &mut cx);
+        bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
         rig.expect_penalty();
     }
 
@@ -902,16 +959,21 @@ fn test_parent_lookup_too_deep() {
             let _ = rig.expect_parent_request(ResponseType::Blob);
         }
         // the block
-        bl.parent_lookup_response(id, peer_id, Some(block.clone()), D, &mut cx);
+        bl.parent_lookup_response::<BlockRequestState<Parent>>(
+            id,
+            peer_id,
+            Some(block.clone()),
+            D,
+            &cx,
+        );
         // the stream termination
-        bl.parent_lookup_response(id, peer_id, None, D, &mut cx);
+        bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
         // the processing request
         rig.expect_block_process(response_type);
         // the processing result
         bl.parent_block_processed(
             chain_hash,
             BlockError::ParentUnknown(block.into()).into(),
-            response_type,
             &mut cx,
         )
     }
@@ -971,7 +1033,13 @@ fn test_single_block_lookup_ignored_response() {
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
     // for processing.
-    bl.single_lookup_response(id, peer_id, Some(block.into()), D, &mut cx);
+    bl.single_lookup_response::<BlockRequestState<Current>>(
+        id,
+        peer_id,
+        Some(block.into()),
+        D,
+        &cx,
+    );
     rig.expect_empty_network();
     rig.expect_block_process(response_type);
 
@@ -980,9 +1048,13 @@ fn test_single_block_lookup_ignored_response() {
 
     // Send the stream termination. Peer should have not been penalized, and the request removed
     // after processing.
-    bl.single_lookup_response(id, peer_id, None, D, &mut cx);
+    bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
     // Send an Ignored response, the request should be dropped
-    bl.single_block_component_processed(id, BlockProcessingResult::Ignored, response_type, &mut cx);
+    bl.single_block_component_processed::<BlockRequestState<Current>>(
+        id,
+        BlockProcessingResult::Ignored,
+        &mut cx,
+    );
     rig.expect_empty_network();
     assert_eq!(bl.single_block_lookups.len(), 0);
 }
@@ -1015,17 +1087,18 @@ fn test_parent_lookup_ignored_response() {
     }
 
     // Peer sends the right block, it should be sent for processing. Peer should not be penalized.
-    bl.parent_lookup_response(id, peer_id, Some(parent.into()), D, &mut cx);
+    bl.parent_lookup_response::<BlockRequestState<Parent>>(
+        id,
+        peer_id,
+        Some(parent.into()),
+        D,
+        &cx,
+    );
     rig.expect_block_process(response_type);
     rig.expect_empty_network();
 
     // Return an Ignored result. The request should be dropped
-    bl.parent_block_processed(
-        chain_hash,
-        BlockProcessingResult::Ignored,
-        response_type,
-        &mut cx,
-    );
+    bl.parent_block_processed(chain_hash, BlockProcessingResult::Ignored, &mut cx);
     rig.expect_empty_network();
     assert_eq!(bl.parent_lookups.len(), 0);
 }
@@ -1092,25 +1165,25 @@ fn test_same_chain_race_condition() {
             let _ = rig.expect_parent_request(ResponseType::Blob);
         }
         // the block
-        bl.parent_lookup_response(id, peer_id, Some(block.clone()), D, &mut cx);
+        bl.parent_lookup_response::<BlockRequestState<Parent>>(
+            id,
+            peer_id,
+            Some(block.clone()),
+            D,
+            &cx,
+        );
         // the stream termination
-        bl.parent_lookup_response(id, peer_id, None, D, &mut cx);
+        bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
         // the processing request
         rig.expect_block_process(response_type);
         // the processing result
         if i + 2 == depth {
             // one block was removed
-            bl.parent_block_processed(
-                chain_hash,
-                BlockError::BlockIsAlreadyKnown.into(),
-                response_type,
-                &mut cx,
-            )
+            bl.parent_block_processed(chain_hash, BlockError::BlockIsAlreadyKnown.into(), &mut cx)
         } else {
             bl.parent_block_processed(
                 chain_hash,
                 BlockError::ParentUnknown(block.into()).into(),
-                response_type,
                 &mut cx,
             )
         }
@@ -1137,7 +1210,7 @@ fn test_same_chain_race_condition() {
     let process_result = BatchProcessResult::Success {
         was_non_empty: true,
     };
-    bl.parent_chain_processed(chain_hash, process_result, &mut cx);
+    bl.parent_chain_processed(chain_hash, process_result, &cx);
     assert_eq!(bl.parent_lookups.len(), 0);
 }
 
@@ -1307,12 +1380,12 @@ mod deneb_only {
 
         fn parent_block_response(mut self) -> Self {
             self.rig.expect_empty_network();
-            self.bl.parent_lookup_response(
+            self.bl.parent_lookup_response::<BlockRequestState<Parent>>(
                 self.parent_block_req_id.expect("parent request id"),
                 self.peer_id,
                 self.parent_block.clone(),
                 D,
-                &mut self.cx,
+                &self.cx,
             );
 
             assert_eq!(self.bl.parent_lookups.len(), 1);
@@ -1321,22 +1394,24 @@ mod deneb_only {
 
         fn parent_blob_response(mut self) -> Self {
             for blob in &self.parent_blobs {
-                self.bl.parent_lookup_blob_response(
-                    self.parent_blob_req_id.expect("parent blob request id"),
+                self.bl
+                    .parent_lookup_response::<BlobRequestState<Parent, E>>(
+                        self.parent_blob_req_id.expect("parent blob request id"),
+                        self.peer_id,
+                        Some(blob.clone()),
+                        D,
+                        &self.cx,
+                    );
+                assert_eq!(self.bl.parent_lookups.len(), 1);
+            }
+            self.bl
+                .parent_lookup_response::<BlobRequestState<Parent, E>>(
+                    self.parent_blob_req_id.expect("blob request id"),
                     self.peer_id,
-                    Some(blob.clone()),
+                    None,
                     D,
-                    &mut self.cx,
+                    &self.cx,
                 );
-                assert_eq!(self.bl.parent_lookups.len(), 1);
-            }
-            self.bl.parent_lookup_blob_response(
-                self.parent_blob_req_id.expect("blob request id"),
-                self.peer_id,
-                None,
-                D,
-                &mut self.cx,
-            );
 
             self
         }
@@ -1353,13 +1428,14 @@ mod deneb_only {
         fn block_response(mut self) -> Self {
             // The peer provides the correct block, should not be penalized. Now the block should be sent
             // for processing.
-            self.bl.single_lookup_response(
-                self.block_req_id.expect("block request id"),
-                self.peer_id,
-                self.block.clone(),
-                D,
-                &mut self.cx,
-            );
+            self.bl
+                .single_lookup_response::<BlockRequestState<Current>>(
+                    self.block_req_id.expect("block request id"),
+                    self.peer_id,
+                    self.block.clone(),
+                    D,
+                    &self.cx,
+                );
             self.rig.expect_empty_network();
 
             // The request should still be active.
@@ -1369,22 +1445,24 @@ mod deneb_only {
 
         fn blobs_response(mut self) -> Self {
             for blob in &self.blobs {
-                self.bl.single_blob_lookup_response(
+                self.bl
+                    .single_lookup_response::<BlobRequestState<Current, E>>(
+                        self.blob_req_id.expect("blob request id"),
+                        self.peer_id,
+                        Some(blob.clone()),
+                        D,
+                        &self.cx,
+                    );
+                assert_eq!(self.bl.single_block_lookups.len(), 1);
+            }
+            self.bl
+                .single_lookup_response::<BlobRequestState<Current, E>>(
                     self.blob_req_id.expect("blob request id"),
                     self.peer_id,
-                    Some(blob.clone()),
+                    None,
                     D,
-                    &mut self.cx,
+                    &self.cx,
                 );
-                assert_eq!(self.bl.single_block_lookups.len(), 1);
-            }
-            self.bl.single_blob_lookup_response(
-                self.blob_req_id.expect("blob request id"),
-                self.peer_id,
-                None,
-                D,
-                &mut self.cx,
-            );
             self
         }
 
@@ -1402,58 +1480,63 @@ mod deneb_only {
         }
 
         fn empty_block_response(mut self) -> Self {
-            self.bl.single_lookup_response(
-                self.block_req_id.expect("block request id"),
-                self.peer_id,
-                None,
-                D,
-                &mut self.cx,
-            );
+            self.bl
+                .single_lookup_response::<BlockRequestState<Current>>(
+                    self.block_req_id.expect("block request id"),
+                    self.peer_id,
+                    None,
+                    D,
+                    &self.cx,
+                );
             self
         }
 
         fn empty_blobs_response(mut self) -> Self {
-            self.bl.single_blob_lookup_response(
-                self.blob_req_id.expect("blob request id"),
-                self.peer_id,
-                None,
-                D,
-                &mut self.cx,
-            );
+            self.bl
+                .single_lookup_response::<BlobRequestState<Current, E>>(
+                    self.blob_req_id.expect("blob request id"),
+                    self.peer_id,
+                    None,
+                    D,
+                    &self.cx,
+                );
             self
         }
 
         fn empty_parent_block_response(mut self) -> Self {
-            self.bl.parent_lookup_response(
+            self.bl.parent_lookup_response::<BlockRequestState<Parent>>(
                 self.parent_block_req_id.expect("block request id"),
                 self.peer_id,
                 None,
                 D,
-                &mut self.cx,
+                &self.cx,
             );
             self
         }
 
         fn empty_parent_blobs_response(mut self) -> Self {
-            self.bl.parent_lookup_blob_response(
-                self.parent_blob_req_id.expect("blob request id"),
-                self.peer_id,
-                None,
-                D,
-                &mut self.cx,
-            );
+            self.bl
+                .parent_lookup_response::<BlobRequestState<Parent, E>>(
+                    self.parent_blob_req_id.expect("blob request id"),
+                    self.peer_id,
+                    None,
+                    D,
+                    &self.cx,
+                );
             self
         }
 
         fn block_imported(mut self) -> Self {
             // Missing blobs should be the request is not removed, the outstanding blobs request should
             // mean we do not send a new request.
-            self.bl.single_block_component_processed(
-                self.block_req_id.expect("block request id"),
-                BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(self.block_root)),
-                ResponseType::Block,
-                &mut self.cx,
-            );
+            self.bl
+                .single_block_component_processed::<BlockRequestState<Current>>(
+                    self.block_req_id.expect("block request id"),
+                    BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(
+                        self.block_root,
+                    )),
+                    &mut self.cx,
+                );
             self.rig.expect_empty_network();
             assert_eq!(self.bl.single_block_lookups.len(), 0);
             self
@@ -1463,7 +1546,6 @@ mod deneb_only {
             self.bl.parent_block_processed(
                 self.block_root,
                 BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(self.block_root)),
-                ResponseType::Block,
                 &mut self.cx,
             );
             self.rig.expect_empty_network();
@@ -1477,7 +1559,6 @@ mod deneb_only {
                 BlockProcessingResult::Err(BlockError::ParentUnknown(RpcBlock::new_without_blobs(
                     self.parent_block.clone().expect("parent block"),
                 ))),
-                ResponseType::Block,
                 &mut self.cx,
             );
             assert_eq!(self.bl.parent_lookups.len(), 1);
@@ -1488,7 +1569,6 @@ mod deneb_only {
             self.bl.parent_block_processed(
                 self.block_root,
                 BlockProcessingResult::Err(BlockError::ProposalSignatureInvalid),
-                ResponseType::Block,
                 &mut self.cx,
             );
             assert_eq!(self.bl.parent_lookups.len(), 1);
@@ -1496,53 +1576,53 @@ mod deneb_only {
         }
 
         fn invalid_block_processed(mut self) -> Self {
-            self.bl.single_block_component_processed(
-                self.block_req_id.expect("block request id"),
-                BlockProcessingResult::Err(BlockError::ProposalSignatureInvalid),
-                ResponseType::Block,
-                &mut self.cx,
-            );
+            self.bl
+                .single_block_component_processed::<BlockRequestState<Current>>(
+                    self.block_req_id.expect("block request id"),
+                    BlockProcessingResult::Err(BlockError::ProposalSignatureInvalid),
+                    &mut self.cx,
+                );
             assert_eq!(self.bl.single_block_lookups.len(), 1);
             self
         }
 
         fn invalid_blob_processed(mut self) -> Self {
-            self.bl.single_block_component_processed(
-                self.blob_req_id.expect("blob request id"),
-                BlockProcessingResult::Err(BlockError::BlobValidation(
-                    BlobError::ProposerSignatureInvalid,
-                )),
-                ResponseType::Blob,
-                &mut self.cx,
-            );
+            self.bl
+                .single_block_component_processed::<BlobRequestState<Current, E>>(
+                    self.blob_req_id.expect("blob request id"),
+                    BlockProcessingResult::Err(BlockError::BlobValidation(
+                        BlobError::ProposerSignatureInvalid,
+                    )),
+                    &mut self.cx,
+                );
             assert_eq!(self.bl.single_block_lookups.len(), 1);
             self
         }
 
         fn missing_components_from_block_request(mut self) -> Self {
-            self.bl.single_block_component_processed(
-                self.block_req_id.expect("block request id"),
-                BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
-                    self.slot,
-                    self.block_root,
-                )),
-                ResponseType::Block,
-                &mut self.cx,
-            );
+            self.bl
+                .single_block_component_processed::<BlockRequestState<Current>>(
+                    self.block_req_id.expect("block request id"),
+                    BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                        self.slot,
+                        self.block_root,
+                    )),
+                    &mut self.cx,
+                );
             assert_eq!(self.bl.single_block_lookups.len(), 1);
             self
         }
 
         fn missing_components_from_blob_request(mut self) -> Self {
-            self.bl.single_block_component_processed(
-                self.blob_req_id.expect("blob request id"),
-                BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
-                    self.slot,
-                    self.block_root,
-                )),
-                ResponseType::Blob,
-                &mut self.cx,
-            );
+            self.bl
+                .single_block_component_processed::<BlobRequestState<Current, E>>(
+                    self.blob_req_id.expect("blob request id"),
+                    BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
+                        self.slot,
+                        self.block_root,
+                    )),
+                    &mut self.cx,
+                );
             assert_eq!(self.bl.single_block_lookups.len(), 1);
             self
         }
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index 31062336580..cedad8890f0 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -44,7 +44,7 @@ use crate::status::ToStatusMessage;
 use crate::sync::block_lookups::delayed_lookup;
 use crate::sync::block_lookups::delayed_lookup::DelayedLookupMessage;
 use crate::sync::block_lookups::{
-    BlobRequestState, BlockRequestState, Current, Parent, RequestState, UnknownParentComponents,
+    BlobRequestState, BlockRequestState, Current, Parent, UnknownParentComponents,
 };
 use crate::sync::range_sync::ByRangeRequestType;
 use beacon_chain::block_verification_types::AsBlock;
@@ -84,7 +84,7 @@ pub const DELAY_QUEUE_CHANNEL_SIZE: usize = 128;
 
 pub type Id = u32;
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub enum ResponseType {
     Block,
     Blob,
@@ -187,7 +187,6 @@ pub enum SyncMessage<T: EthSpec> {
     BlockComponentProcessed {
         process_type: BlockProcessType,
         result: BlockProcessingResult<T>,
-        response_type: ResponseType,
     },
 }
 
@@ -350,7 +349,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     .single_block_lookup_failed::<BlockRequestState<Current>>(
                         id,
                         &peer_id,
-                        &mut self.network,
+                        &self.network,
                         error,
                     );
             }
@@ -359,7 +358,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     .single_block_lookup_failed::<BlobRequestState<Current, T::EthSpec>>(
                         id,
                         &peer_id,
-                        &mut self.network,
+                        &self.network,
                         error,
                     );
             }
@@ -368,7 +367,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     .parent_lookup_failed::<BlockRequestState<Parent>>(
                         id,
                         peer_id,
-                        &mut self.network,
+                        &self.network,
                         error,
                     );
             }
@@ -377,7 +376,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     .parent_lookup_failed::<BlobRequestState<Parent, T::EthSpec>>(
                         id,
                         peer_id,
-                        &mut self.network,
+                        &self.network,
                         error,
                     );
             }
@@ -701,7 +700,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                         self.block_lookups.search_block_delayed(
                             block_root,
                             PeerShouldHave::Neither(peer_id),
-                            &self.network,
+                            &mut self.network,
                         );
                         if let Err(e) = self
                             .delayed_lookups
@@ -722,7 +721,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             SyncMessage::MissingGossipBlockComponentsDelayed(block_root) => {
                 if self
                     .block_lookups
-                    .trigger_lookup_by_root(block_root, &mut self.network)
+                    .trigger_lookup_by_root(block_root, &self.network)
                     .is_err()
                 {
                     // No request was made for block or blob so the lookup is dropped.
@@ -740,25 +739,24 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             SyncMessage::BlockComponentProcessed {
                 process_type,
                 result,
-                response_type,
             } => match process_type {
                 BlockProcessType::SingleBlock { id } => self
                     .block_lookups
                     .single_block_component_processed::<BlockRequestState<Current>>(
                         id,
                         result,
-                        &self.network,
+                        &mut self.network,
                     ),
                 BlockProcessType::SingleBlob { id } => self
                     .block_lookups
                     .single_block_component_processed::<BlobRequestState<Current, T::EthSpec>>(
                         id,
                         result,
-                        &self.network,
+                        &mut self.network,
                     ),
                 BlockProcessType::ParentLookup { chain_hash } => self
                     .block_lookups
-                    .parent_block_processed(chain_hash, result, response_type, &mut self.network),
+                    .parent_block_processed(chain_hash, result, &mut self.network),
             },
             SyncMessage::BatchProcessed { sync_type, result } => match sync_type {
                 ChainSegmentProcessId::RangeBatchId(chain_id, epoch) => {
@@ -787,7 +785,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                 }
                 ChainSegmentProcessId::ParentLookup(chain_hash) => self
                     .block_lookups
-                    .parent_chain_processed(chain_hash, result, &mut self.network),
+                    .parent_chain_processed(chain_hash, result, &self.network),
             },
         }
     }
@@ -813,7 +811,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     block_root,
                     parent_components,
                     &[PeerShouldHave::Neither(peer_id)],
-                    &self.network,
+                    &mut self.network,
                 );
                 if let Err(e) = self
                     .delayed_lookups
@@ -953,7 +951,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     seen_timestamp,
                     &self.network,
                 ),
-            RequestId::SingleBlob { id } => {
+            RequestId::SingleBlob { id: _ } => {
                 crit!(self.log, "Blob received during block request"; "peer_id" => %peer_id  );
             }
             RequestId::ParentLookup { id } => self
@@ -965,7 +963,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     seen_timestamp,
                     &self.network,
                 ),
-            RequestId::ParentLookupBlob { id } => {
+            RequestId::ParentLookupBlob { id: _ } => {
                 crit!(self.log, "Blob received during parent block request"; "peer_id" => %peer_id  );
             }
             RequestId::BackFillBlocks { id } => {
@@ -1025,7 +1023,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         seen_timestamp: Duration,
     ) {
         match request_id {
-            RequestId::SingleBlock { id } => {
+            RequestId::SingleBlock { id: _ } => {
                 crit!(self.log, "Single blob received during block request"; "peer_id" => %peer_id  );
             }
             RequestId::SingleBlob { id } => self
@@ -1035,10 +1033,10 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     peer_id,
                     blob,
                     seen_timestamp,
-                    &mut self.network,
+                    &self.network,
                 ),
 
-            RequestId::ParentLookup { id } => {
+            RequestId::ParentLookup { id: _ } => {
                 crit!(self.log, "Single blob received during parent block request"; "peer_id" => %peer_id  );
             }
             RequestId::ParentLookupBlob { id } => self
@@ -1048,7 +1046,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     peer_id,
                     blob,
                     seen_timestamp,
-                    &mut self.network,
+                    &self.network,
                 ),
             RequestId::BackFillBlocks { id: _ } => {
                 crit!(self.log, "Blob received during backfill block request"; "peer_id" => %peer_id  );
diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs
index 21c25a1e5df..b7c6de2fc63 100644
--- a/beacon_node/network/src/sync/network_context.rs
+++ b/beacon_node/network/src/sync/network_context.rs
@@ -7,7 +7,7 @@ use super::range_sync::{BatchId, ByRangeRequestType, ChainId};
 use crate::network_beacon_processor::NetworkBeaconProcessor;
 use crate::service::{NetworkMessage, RequestId};
 use crate::status::ToStatusMessage;
-use crate::sync::block_lookups::{BlobRequestId, BlockRequestId};
+use crate::sync::block_lookups::LookupType;
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{BeaconChain, BeaconChainTypes, EngineState};
 use fnv::FnvHashMap;
@@ -37,7 +37,7 @@ pub struct SyncNetworkContext<T: BeaconChainTypes> {
     network_send: mpsc::UnboundedSender<NetworkMessage<T::EthSpec>>,
 
     /// A sequential ID for all RPC requests.
-    request_id: std::cell::Cell<Id>,
+    request_id: Id,
 
     /// BlocksByRange requests made by the range syncing algorithm.
     range_requests: FnvHashMap<Id, (ChainId, BatchId)>,
@@ -93,7 +93,7 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         SyncNetworkContext {
             network_send,
             execution_engine_state: EngineState::Online, // always assume `Online` at the start
-            request_id: std::cell::Cell::new(1),
+            request_id: 1,
             range_requests: FnvHashMap::default(),
             backfill_requests: FnvHashMap::default(),
             range_blocks_and_blobs_requests: FnvHashMap::default(),
@@ -463,7 +463,8 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
                 "Sending BlobsByRoot Request";
                 "method" => "BlobsByRoot",
                 "count" => blob_request.blob_ids.len(),
-                "peer" => %blob_peer_id
+                "peer" => %blob_peer_id,
+                "lookup_type" => ?lookup_type
             );
 
             self.send_network_msg(NetworkMessage::SendRequest {
@@ -539,10 +540,10 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         &self.network_beacon_processor
     }
 
-    pub fn next_id(&self) -> Id {
-        let current_value = self.request_id.get();
-        self.request_id.set(current_value + 1);
-        current_value
+    pub(crate) fn next_id(&mut self) -> Id {
+        let id = self.request_id;
+        self.request_id += 1;
+        id
     }
 
     /// Check whether a batch for this epoch (and only this epoch) should request just blocks or

From 6bcfaf4fdea843302d4333d639a504a87e9690e8 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Tue, 1 Aug 2023 17:14:45 -0400
Subject: [PATCH 06/18] clean up everything add child component, fix peer
 scoring and retry logic

---
 .../src/block_verification_types.rs           |   18 +
 .../src/network_beacon_processor/mod.rs       |    4 +
 .../src/network_beacon_processor/tests.rs     |    2 +
 .../network/src/sync/block_lookups/common.rs  |  448 +++++++
 .../network/src/sync/block_lookups/mod.rs     | 1109 +++++++++++------
 .../src/sync/block_lookups/parent_lookup.rs   |   72 +-
 .../sync/block_lookups/single_block_lookup.rs |  955 +++++---------
 .../network/src/sync/block_lookups/tests.rs   |   44 +-
 beacon_node/network/src/sync/manager.rs       |   78 +-
 beacon_node/network/src/sync/mod.rs           |    2 +-
 .../network/src/sync/network_context.rs       |   37 +-
 11 files changed, 1596 insertions(+), 1173 deletions(-)
 create mode 100644 beacon_node/network/src/sync/block_lookups/common.rs

diff --git a/beacon_node/beacon_chain/src/block_verification_types.rs b/beacon_node/beacon_chain/src/block_verification_types.rs
index c41090c421f..ab110c2104e 100644
--- a/beacon_node/beacon_chain/src/block_verification_types.rs
+++ b/beacon_node/beacon_chain/src/block_verification_types.rs
@@ -5,8 +5,10 @@ use crate::eth1_finalization_cache::Eth1FinalizationData;
 use crate::{data_availability_checker, GossipVerifiedBlock, PayloadVerificationOutcome};
 use derivative::Derivative;
 use ssz_derive::{Decode, Encode};
+use ssz_types::VariableList;
 use state_processing::ConsensusContext;
 use std::sync::Arc;
+use types::blob_sidecar::FixedBlobSidecarList;
 use types::{
     blob_sidecar::BlobIdentifier, ssz_tagged_beacon_state, ssz_tagged_signed_beacon_block,
     ssz_tagged_signed_beacon_block_arc,
@@ -72,6 +74,22 @@ impl<E: EthSpec> RpcBlock<E> {
         Ok(Self { block: inner })
     }
 
+    pub fn new_from_fixed(
+        block: Arc<SignedBeaconBlock<E>>,
+        blobs: FixedBlobSidecarList<E>,
+    ) -> Result<Self, AvailabilityCheckError> {
+        let filtered = blobs
+            .into_iter()
+            .filter_map(|b| b.clone())
+            .collect::<Vec<_>>();
+        let blobs = if filtered.is_empty() {
+            None
+        } else {
+            Some(VariableList::from(filtered))
+        };
+        Self::new(block, blobs)
+    }
+
     pub fn deconstruct(self) -> (Arc<SignedBeaconBlock<E>>, Option<BlobSidecarList<E>>) {
         match self.block {
             RpcBlockInner::Block(block) => (block, None),
diff --git a/beacon_node/network/src/network_beacon_processor/mod.rs b/beacon_node/network/src/network_beacon_processor/mod.rs
index 4a214c3637a..3906dcaaf6f 100644
--- a/beacon_node/network/src/network_beacon_processor/mod.rs
+++ b/beacon_node/network/src/network_beacon_processor/mod.rs
@@ -434,6 +434,10 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         seen_timestamp: Duration,
         process_type: BlockProcessType,
     ) -> Result<(), Error<T::EthSpec>> {
+        let blob_count = blobs.iter().filter(|b| b.is_some()).count();
+        if blob_count == 0 {
+            return Ok(());
+        }
         let process_fn = self.clone().generate_rpc_blobs_process_fn(
             block_root,
             blobs,
diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs
index 2c37d177aab..1bdc3a88166 100644
--- a/beacon_node/network/src/network_beacon_processor/tests.rs
+++ b/beacon_node/network/src/network_beacon_processor/tests.rs
@@ -318,6 +318,7 @@ impl TestRig {
     }
     pub fn enqueue_single_lookup_rpc_blobs(&self) {
         if let Some(blobs) = self.next_blobs.clone() {
+            dbg!(blobs.len());
             let blobs = FixedBlobSidecarList::from(
                 blobs
                     .into_iter()
@@ -1003,6 +1004,7 @@ async fn test_rpc_block_reprocessing() {
 
     rig.enqueue_single_lookup_rpc_blobs();
     if rig.next_blobs.as_ref().map(|b| b.len()).unwrap_or(0) > 0 {
+        dbg!("here");
         rig.assert_event_journal(&[RPC_BLOBS, WORKER_FREED, NOTHING_TO_DO])
             .await;
     }
diff --git a/beacon_node/network/src/sync/block_lookups/common.rs b/beacon_node/network/src/sync/block_lookups/common.rs
new file mode 100644
index 00000000000..b4711e26be5
--- /dev/null
+++ b/beacon_node/network/src/sync/block_lookups/common.rs
@@ -0,0 +1,448 @@
+use crate::sync::block_lookups::parent_lookup::PARENT_FAIL_TOLERANCE;
+use crate::sync::block_lookups::single_block_lookup::{
+    LookupRequestError, LookupVerifyError, SingleBlockLookup, SingleLookupRequestState, State,
+};
+use crate::sync::block_lookups::{
+    BlobRequestState, BlockLookups, BlockRequestState, PeerShouldHave,
+    SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS,
+};
+use crate::sync::manager::{BlockProcessType, Id, SingleLookupReqId};
+use crate::sync::network_context::SyncNetworkContext;
+use crate::sync::ChildComponents;
+use beacon_chain::block_verification_types::RpcBlock;
+use beacon_chain::{get_block_root, BeaconChainTypes};
+use lighthouse_network::rpc::methods::BlobsByRootRequest;
+use lighthouse_network::rpc::BlocksByRootRequest;
+use lighthouse_network::PeerId;
+use rand::prelude::IteratorRandom;
+use ssz_types::VariableList;
+use std::ops::IndexMut;
+use std::sync::Arc;
+use std::time::Duration;
+use types::blob_sidecar::FixedBlobSidecarList;
+use types::{BlobSidecar, EthSpec, Hash256, SignedBeaconBlock};
+
+#[derive(Debug, Copy, Clone)]
+pub enum ResponseType {
+    Block,
+    Blob,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum LookupType {
+    Current,
+    Parent,
+}
+
+/// This trait helps differentiate `SingleBlockLookup`s from `ParentLookup`s .This is useful in
+/// ensuring requests and responses are handled separately and enables us to use different failure
+/// tolerances for each, while re-using the same basic request and retry logic.
+pub trait Lookup {
+    const MAX_ATTEMPTS: u8;
+    fn lookup_type() -> LookupType;
+    fn max_attempts() -> u8 {
+        Self::MAX_ATTEMPTS
+    }
+}
+
+/// A `Lookup` that is a part of a `ParentLookup`.
+pub struct Parent;
+
+impl Lookup for Parent {
+    const MAX_ATTEMPTS: u8 = PARENT_FAIL_TOLERANCE;
+    fn lookup_type() -> LookupType {
+        LookupType::Parent
+    }
+}
+
+/// A `Lookup` that part of a single block lookup.
+pub struct Current;
+
+impl Lookup for Current {
+    const MAX_ATTEMPTS: u8 = SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS;
+    fn lookup_type() -> LookupType {
+        LookupType::Current
+    }
+}
+
+/// 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<L: Lookup, T: BeaconChainTypes> {
+    /// The type of the request .
+    type RequestType;
+
+    /// A block or blob response.
+    type ResponseType;
+
+    /// The type created after validation.
+    type VerifiedResponseType: Clone;
+
+    /// We convert a `VerifiedResponseType` to this type prior to sending it to the beacon processor.
+    type ReconstructedResponseType;
+
+    /* Request building methods */
+
+    /// Construct a new request.
+    fn build_request(&mut self) -> Result<(PeerId, Self::RequestType), LookupRequestError> {
+        debug_assert!(matches!(self.get_state().state, State::AwaitingDownload));
+        self.too_many_attempts()?;
+        let peer = self.get_peer()?;
+        let request = self.new_request();
+        self.get_state_mut().req_counter += 1;
+        Ok((peer, request))
+    }
+
+    /// Verify the current request has not exceeded the maximum number of attempts.
+    fn too_many_attempts(&self) -> Result<(), LookupRequestError> {
+        let max_attempts = L::max_attempts();
+        let request_state = self.get_state();
+
+        if request_state.failed_attempts() >= max_attempts {
+            let cannot_process =
+                request_state.failed_processing >= request_state.failed_downloading;
+            Err(LookupRequestError::TooManyAttempts { cannot_process })
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Get the next peer to request. Draws from the set of peers we think should have both the
+    /// block and blob first. If that fails, we draw from the set of peers that may have either.
+    fn get_peer(&mut self) -> Result<PeerId, LookupRequestError> {
+        let request_state = self.get_state_mut();
+        let available_peer_opt = request_state
+            .available_peers
+            .iter()
+            .choose(&mut rand::thread_rng())
+            .copied()
+            .map(PeerShouldHave::BlockAndBlobs);
+
+        let Some(peer_id) = available_peer_opt.or_else(||request_state
+            .potential_peers
+            .iter()
+            .choose(&mut rand::thread_rng())
+            .copied()
+            .map(PeerShouldHave::Neither)) else {
+            return Err(LookupRequestError::NoPeers);
+        };
+        request_state.used_peers.insert(peer_id.to_peer_id());
+        request_state.state = State::Downloading { peer_id };
+        Ok(peer_id.to_peer_id())
+    }
+
+    /// Initialize `Self::RequestType`.
+    fn new_request(&self) -> Self::RequestType;
+
+    /// Send the request to the network service.
+    fn make_request(
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        request: Self::RequestType,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError>;
+
+    /* Response handling methods */
+
+    /// Verify the response is valid based on what we requested.
+    fn verify_response(
+        &mut self,
+        expected_block_root: Hash256,
+        response: Option<Self::ResponseType>,
+    ) -> Result<Option<Self::VerifiedResponseType>, LookupVerifyError> {
+        let request_state = self.get_state_mut();
+        match request_state.state {
+            State::AwaitingDownload => {
+                request_state.register_failure_downloading();
+                Err(LookupVerifyError::ExtraBlocksReturned)
+            }
+            State::Downloading { peer_id } => {
+                self.verify_response_inner(expected_block_root, response, peer_id)
+            }
+            State::Processing { peer_id: _ } => match response {
+                Some(_) => {
+                    // We sent the block for processing and received an extra block.
+                    request_state.register_failure_downloading();
+                    Err(LookupVerifyError::ExtraBlocksReturned)
+                }
+                None => {
+                    // This is simply the stream termination and we are already processing the
+                    // block
+                    Ok(None)
+                }
+            },
+        }
+    }
+
+    /// The response verification unique to block or blobs.
+    fn verify_response_inner(
+        &mut self,
+        expected_block_root: Hash256,
+        response: Option<Self::ResponseType>,
+        peer_id: PeerShouldHave,
+    ) -> Result<Option<Self::VerifiedResponseType>, LookupVerifyError>;
+
+    /// A getter for the parent root of the response. Returns an `Option` because we won't know
+    /// the blob parent if we don't end up getting any blobs in the response.
+    fn get_parent_root(verified_response: &Self::VerifiedResponseType) -> Option<Hash256>;
+
+    /// Caches the verified response in the lookup if necessary. This is only necessary for lookups
+    /// triggered by `UnknownParent` errors.
+    fn add_to_child_components(
+        verified_response: Self::VerifiedResponseType,
+        components: &mut ChildComponents<T::EthSpec>,
+    );
+
+    /// Convert a verified response to the type we send to the beacon processor.
+    fn verified_to_reconstructed(
+        verified: Self::VerifiedResponseType,
+    ) -> Self::ReconstructedResponseType;
+
+    /// Send the response to the beacon processor.
+    fn send_for_processing(
+        id: Id,
+        bl: &BlockLookups<T>,
+        block_root: Hash256,
+        verified: Self::ReconstructedResponseType,
+        duration: Duration,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError>;
+
+    /// Remove the peer from the lookup if it is useless.
+    fn remove_if_useless(&mut self, peer: &PeerId) {
+        self.get_state_mut().remove_peer_if_useless(peer)
+    }
+
+    /// Register a failure to process the block or blob.
+    fn register_failure_downloading(&mut self) {
+        self.get_state_mut().register_failure_downloading()
+    }
+
+    /* 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<L, T>) -> &mut Self;
+
+    /// A getter for a reference to the `SingleLookupRequestState` associated with this trait.
+    fn get_state(&self) -> &SingleLookupRequestState;
+
+    /// A getter for a mutable reference to the SingleLookupRequestState associated with this trait.
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState;
+}
+
+impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlockRequestState<L> {
+    type RequestType = BlocksByRootRequest;
+    type ResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
+    type VerifiedResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
+    type ReconstructedResponseType = RpcBlock<T::EthSpec>;
+
+    fn new_request(&self) -> BlocksByRootRequest {
+        BlocksByRootRequest::new(VariableList::from(vec![self.requested_block_root]))
+    }
+
+    fn make_request(
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        request: Self::RequestType,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        cx.block_lookup_request(id, peer_id, request, L::lookup_type())
+            .map_err(LookupRequestError::SendFailed)
+    }
+
+    fn verify_response_inner(
+        &mut self,
+        expected_block_root: Hash256,
+        response: Option<Self::ResponseType>,
+        peer_id: PeerShouldHave,
+    ) -> Result<Option<Arc<SignedBeaconBlock<T::EthSpec>>>, LookupVerifyError> {
+        match response {
+            Some(block) => {
+                // Compute the block root using this specific function so that we can get timing
+                // metrics.
+                let block_root = get_block_root(&block);
+                if block_root != expected_block_root {
+                    // return an error and drop the block
+                    // NOTE: we take this is as a download failure to prevent counting the
+                    // attempt as a chain failure, but simply a peer failure.
+                    self.state.register_failure_downloading();
+                    Err(LookupVerifyError::RootMismatch)
+                } else {
+                    // Return the block for processing.
+                    self.state.state = State::Processing { peer_id };
+                    Ok(Some(block))
+                }
+            }
+            None => {
+                if peer_id.should_have_block() {
+                    self.state.register_failure_downloading();
+                    Err(LookupVerifyError::NoBlockReturned)
+                } else {
+                    self.state.state = State::AwaitingDownload;
+                    Err(LookupVerifyError::BenignFailure)
+                }
+            }
+        }
+    }
+
+    fn get_parent_root(verified_response: &Arc<SignedBeaconBlock<T::EthSpec>>) -> Option<Hash256> {
+        Some(verified_response.parent_root())
+    }
+
+    fn add_to_child_components(
+        verified_response: Arc<SignedBeaconBlock<T::EthSpec>>,
+        components: &mut ChildComponents<T::EthSpec>,
+    ) {
+        components.add_unknown_parent_block(verified_response);
+    }
+
+    fn verified_to_reconstructed(
+        block: Arc<SignedBeaconBlock<T::EthSpec>>,
+    ) -> RpcBlock<T::EthSpec> {
+        RpcBlock::new_without_blobs(block)
+    }
+
+    fn send_for_processing(
+        id: Id,
+        bl: &BlockLookups<T>,
+        block_root: Hash256,
+        constructed: RpcBlock<T::EthSpec>,
+        duration: Duration,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        bl.send_block_for_processing(
+            block_root,
+            constructed,
+            duration,
+            BlockProcessType::SingleBlock { id },
+            cx,
+        )
+    }
+
+    fn response_type() -> ResponseType {
+        ResponseType::Block
+    }
+    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
+        &mut request.block_request_state
+    }
+    fn get_state(&self) -> &SingleLookupRequestState {
+        &self.state
+    }
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
+        &mut self.state
+    }
+}
+
+impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlobRequestState<L, T::EthSpec> {
+    type RequestType = BlobsByRootRequest;
+    type ResponseType = Arc<BlobSidecar<T::EthSpec>>;
+    type VerifiedResponseType = FixedBlobSidecarList<T::EthSpec>;
+    type ReconstructedResponseType = FixedBlobSidecarList<T::EthSpec>;
+
+    fn new_request(&self) -> BlobsByRootRequest {
+        BlobsByRootRequest {
+            blob_ids: VariableList::from(self.requested_ids.clone()),
+        }
+    }
+
+    fn make_request(
+        id: SingleLookupReqId,
+        peer_id: PeerId,
+        request: Self::RequestType,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        cx.blob_lookup_request(id, peer_id, request, L::lookup_type())
+            .map_err(LookupRequestError::SendFailed)
+    }
+
+    fn verify_response_inner(
+        &mut self,
+        _expected_block_root: Hash256,
+        blob: Option<Self::ResponseType>,
+        peer_id: PeerShouldHave,
+    ) -> Result<Option<FixedBlobSidecarList<T::EthSpec>>, LookupVerifyError> {
+        match blob {
+            Some(blob) => {
+                let received_id = blob.id();
+                if !self.requested_ids.contains(&received_id) {
+                    self.state.register_failure_downloading();
+                    Err(LookupVerifyError::UnrequestedBlobId)
+                } else {
+                    // State should remain downloading until we receive the stream terminator.
+                    self.requested_ids.retain(|id| *id != received_id);
+                    let blob_index = blob.index;
+
+                    if blob_index >= T::EthSpec::max_blobs_per_block() as u64 {
+                        return Err(LookupVerifyError::InvalidIndex(blob.index));
+                    }
+                    *self.blob_download_queue.index_mut(blob_index as usize) = Some(blob);
+                    Ok(None)
+                }
+            }
+            None => {
+                self.state.state = State::Processing { peer_id };
+                let blobs = std::mem::take(&mut self.blob_download_queue);
+                Ok(Some(blobs))
+            }
+        }
+    }
+
+    fn get_parent_root(verified_response: &FixedBlobSidecarList<T::EthSpec>) -> Option<Hash256> {
+        verified_response
+            .into_iter()
+            .filter_map(|blob| blob.as_ref())
+            .map(|blob| blob.block_parent_root)
+            .next()
+    }
+
+    fn add_to_child_components(
+        verified_response: FixedBlobSidecarList<T::EthSpec>,
+        components: &mut ChildComponents<T::EthSpec>,
+    ) {
+        components.add_unknown_parent_blobs(verified_response);
+    }
+
+    fn verified_to_reconstructed(
+        blobs: FixedBlobSidecarList<T::EthSpec>,
+    ) -> FixedBlobSidecarList<T::EthSpec> {
+        blobs
+    }
+
+    fn send_for_processing(
+        id: Id,
+        bl: &BlockLookups<T>,
+        block_root: Hash256,
+        verified: FixedBlobSidecarList<T::EthSpec>,
+        duration: Duration,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        bl.send_blobs_for_processing(
+            block_root,
+            verified,
+            duration,
+            BlockProcessType::SingleBlob { id },
+            cx,
+        )
+    }
+
+    fn response_type() -> ResponseType {
+        ResponseType::Blob
+    }
+    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
+        &mut request.blob_request_state
+    }
+    fn get_state(&self) -> &SingleLookupRequestState {
+        &self.state
+    }
+    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
+        &mut self.state
+    }
+}
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 79ef277468f..43fb5330181 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -5,31 +5,38 @@ use super::BatchProcessResult;
 use super::{manager::BlockProcessType, network_context::SyncNetworkContext};
 use crate::metrics;
 use crate::network_beacon_processor::ChainSegmentProcessId;
-use crate::sync::block_lookups::parent_lookup::ParentLookup;
-use crate::sync::block_lookups::single_block_lookup::LookupVerifyError;
-use crate::sync::manager::{Id, ResponseType};
+use crate::sync::block_lookups::parent_lookup::{ParentLookup, RequestError};
+use crate::sync::block_lookups::single_block_lookup::{
+    CachedChild, LookupRequestError, LookupVerifyError,
+};
+use crate::sync::manager::{Id, SingleLookupReqId};
 use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
-use beacon_chain::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
+use beacon_chain::data_availability_checker::DataAvailabilityChecker;
+use beacon_chain::validator_monitor::timestamp_now;
 use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
+pub use common::Current;
+pub use common::Lookup;
+use common::LookupType;
+pub use common::Parent;
+pub use common::RequestState;
 use fnv::FnvHashMap;
 use lighthouse_network::rpc::RPCError;
 use lighthouse_network::{PeerAction, PeerId};
 use lru_cache::LRUTimeCache;
-pub use single_block_lookup::UnknownParentComponents;
-pub use single_block_lookup::{
-    BlobRequestState, BlockRequestState, Current, Lookup, Parent, RequestState,
-};
+pub use single_block_lookup::ChildComponents;
+pub use single_block_lookup::{BlobRequestState, BlockRequestState};
 use slog::{debug, error, trace, warn, Logger};
 use smallvec::SmallVec;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::sync::Arc;
 use std::time::Duration;
-use store::{Hash256, SignedBeaconBlock};
+use store::Hash256;
 use strum::Display;
 use types::blob_sidecar::FixedBlobSidecarList;
 use types::Slot;
 
+pub mod common;
 pub(crate) mod delayed_lookup;
 mod parent_lookup;
 mod single_block_lookup;
@@ -37,29 +44,10 @@ mod single_block_lookup;
 mod tests;
 
 pub type DownloadedBlocks<T> = (Hash256, RpcBlock<T>);
-pub type RootBlockTuple<T> = (Hash256, Arc<SignedBeaconBlock<T>>);
-pub type RootBlobsTuple<T> = (Hash256, FixedBlobSidecarList<T>);
 
 const FAILED_CHAINS_CACHE_EXPIRY_SECONDS: u64 = 60;
 pub const SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS: u8 = 3;
 
-pub struct BlockLookups<T: BeaconChainTypes> {
-    /// Parent chain lookups being downloaded.
-    parent_lookups: SmallVec<[ParentLookup<T>; 3]>,
-
-    processing_parent_lookups: HashMap<Hash256, (Vec<Hash256>, SingleBlockLookup<Parent, T>)>,
-
-    /// A cache of failed chain lookups to prevent duplicate searches.
-    failed_chains: LRUTimeCache<Hash256>,
-
-    single_block_lookups: FnvHashMap<Id, SingleBlockLookup<Current, T>>,
-
-    da_checker: Arc<DataAvailabilityChecker<T>>,
-
-    /// The logger for the import manager.
-    log: Logger,
-}
-
 /// This enum is used to track what a peer *should* be able to respond with respond based on
 /// other messages we've seen from this peer on the network. This is useful for peer scoring.
 /// We expect a peer tracked by the `BlockAndBlobs` variant to be able to respond to all
@@ -97,6 +85,23 @@ impl PeerShouldHave {
     }
 }
 
+pub struct BlockLookups<T: BeaconChainTypes> {
+    /// Parent chain lookups being downloaded.
+    parent_lookups: SmallVec<[ParentLookup<T>; 3]>,
+
+    processing_parent_lookups: HashMap<Hash256, (Vec<Hash256>, SingleBlockLookup<Parent, T>)>,
+
+    /// A cache of failed chain lookups to prevent duplicate searches.
+    failed_chains: LRUTimeCache<Hash256>,
+
+    single_block_lookups: FnvHashMap<Id, SingleBlockLookup<Current, T>>,
+
+    da_checker: Arc<DataAvailabilityChecker<T>>,
+
+    /// The logger for the import manager.
+    log: Logger,
+}
+
 impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn new(da_checker: Arc<DataAvailabilityChecker<T>>, log: Logger) -> Self {
         Self {
@@ -143,14 +148,14 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
 
     /// Creates a lookup for the block with the given `block_root`, while caching other block
     /// components we've already received. The block components are cached here because we haven't
-    /// imported it's parent and therefore can't fully validate it and store it in the data
+    /// imported its parent and therefore can't fully validate it and store it in the data
     /// availability cache.
     ///
     /// The request is immediately triggered.
     pub fn search_child_block(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<UnknownParentComponents<T::EthSpec>>,
+        parent_components: Option<ChildComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) {
@@ -170,7 +175,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn search_child_delayed(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<UnknownParentComponents<T::EthSpec>>,
+        parent_components: Option<ChildComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) {
@@ -186,13 +191,19 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         mut single_block_lookup: SingleBlockLookup<Current, T>,
         cx: &SyncNetworkContext<T>,
     ) {
-        if !single_block_lookup.triggered && single_block_lookup.request_block_and_blobs(cx).is_ok()
-        {
-            single_block_lookup.triggered = true;
-            self.add_single_lookup(single_block_lookup)
+        let block_root = single_block_lookup.block_root();
+        match single_block_lookup.request_block_and_blobs(cx) {
+            Ok(()) => self.add_single_lookup(single_block_lookup),
+            Err(e) => {
+                debug!(self.log, "Single block lookup failed";
+                    "error" => ?e,
+                    "block_root" => ?block_root,
+                );
+            }
         }
     }
 
+    /// Adds a lookup to the `single_block_lookups` map.
     pub fn add_single_lookup(&mut self, single_block_lookup: SingleBlockLookup<Current, T>) {
         self.single_block_lookups
             .insert(single_block_lookup.id, single_block_lookup);
@@ -203,25 +214,20 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         );
     }
 
-    pub fn trigger_lookup_by_root(
-        &mut self,
-        block_root: Hash256,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), ()> {
-        for (_, lookup) in self.single_block_lookups.iter_mut() {
-            if lookup.block_request_state.requested_block_root == block_root
-                && !lookup.triggered
-                && lookup.request_block_and_blobs(cx).is_ok()
-            {
-                lookup.triggered = true;
+    /// Trigger any lookups that are waiting for the given `block_root`.
+    pub fn trigger_lookup_by_root(&mut self, block_root: Hash256, cx: &SyncNetworkContext<T>) {
+        self.single_block_lookups.retain(|_id, lookup| {
+            if lookup.block_root() == block_root {
+                if let Err(e) = lookup.request_block_and_blobs(cx) {
+                    debug!(self.log, "Delayed single block lookup failed";
+                        "error" => ?e,
+                        "block_root" => ?block_root,
+                    );
+                    return false;
+                }
             }
-        }
-        Ok(())
-    }
-
-    pub fn remove_lookup_by_root(&mut self, block_root: Hash256) {
-        self.single_block_lookups
-            .retain(|_id, lookup| lookup.block_request_state.requested_block_root != block_root);
+            true
+        });
     }
 
     /// Searches for a single block hash. If the blocks parent is unknown, a chain of blocks is
@@ -229,7 +235,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn new_current_lookup(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<UnknownParentComponents<T::EthSpec>>,
+        parent_components: Option<ChildComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) -> Option<SingleBlockLookup<Current, T>> {
@@ -241,7 +247,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         {
             lookup.add_peers(peers);
             if let Some(components) = parent_components {
-                lookup.add_unknown_parent_components(components);
+                lookup.add_child_components(components);
             }
             return None;
         }
@@ -319,37 +325,68 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             // we are already processing this block, ignore it.
             return;
         }
-        let mut parent_lookup = ParentLookup::new(
+        let parent_lookup = ParentLookup::new(
             block_root,
             parent_root,
             peer_source,
             self.da_checker.clone(),
             cx,
         );
-        if let Ok(()) = parent_lookup
-            .current_parent_request
-            .request_block_and_blobs(cx)
-        {
-            self.parent_lookups.push(parent_lookup);
-        }
+        self.request_parent(parent_lookup, cx);
     }
 
     /* Lookup responses */
 
+    /// Get a single block lookup by its ID. This method additionally ensures the `req_counter`
+    /// matches the current `req_counter` for the lookup. This any stale responses from requests
+    /// that have been retried are ignored.
+    fn get_single_lookup<R: RequestState<Current, T>>(
+        &mut self,
+        id: SingleLookupReqId,
+    ) -> Option<SingleBlockLookup<Current, T>> {
+        let mut lookup = self.single_block_lookups.remove(&id.id)?;
+
+        let request_state = R::request_state_mut(&mut lookup);
+        if id.req_counter != request_state.get_state().req_counter {
+            // We don't want to drop the lookup, just ignore the old response.
+            self.single_block_lookups.insert(id.id, lookup);
+            return None;
+        }
+        Some(lookup)
+    }
+
+    /// Checks whether a single block lookup is waiting for a parent lookup to complete. This is
+    /// necessary because we want to make sure all parents are processed before sending a child
+    /// for processing, otherwise the block will fail validation and will be returned to the network
+    /// layer with an `UnknownParent` error.
+    pub fn has_pending_parent_request(&self, target_id: Id) -> bool {
+        self.single_block_lookups.iter().any(|(id, lookup)| {
+            if *id == target_id {
+                self.parent_lookups
+                    .iter()
+                    .any(|parent_lookup| parent_lookup.chain_hash() == lookup.block_root())
+            } else {
+                false
+            }
+        })
+    }
+
+    /// Process a block or blob response received from a single lookup request.
     pub fn single_lookup_response<R: RequestState<Current, T>>(
         &mut self,
-        id: Id,
+        lookup_id: SingleLookupReqId,
         peer_id: PeerId,
         response: Option<R::ResponseType>,
         seen_timestamp: Duration,
         cx: &SyncNetworkContext<T>,
     ) {
-        let is_stream_terminator = response.is_none();
+        let id = lookup_id.id;
         let response_type = R::response_type();
-        let log = self.log.clone();
 
-        let Some(lookup) = self.single_block_lookups.get_mut(&id) else {
-            if !is_stream_terminator {
+        let chain_hash_opt = self.has_pending_parent_request(id);
+
+        let Some(lookup) = self.get_single_lookup::<R>(lookup_id) else {
+            if response.is_some() {
                 warn!(
                     self.log,
                     "Block returned for single block lookup not present";
@@ -359,150 +396,258 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             return;
         };
 
-        let expected_block_root = lookup.block_request_state.requested_block_root;
+        let expected_block_root = lookup.block_root();
 
-        let has_pending_parent_request = self
-            .parent_lookups
-            .iter()
-            .any(|parent_lookup| parent_lookup.chain_hash() == expected_block_root);
+        match self.single_lookup_response_inner::<R>(
+            peer_id,
+            response,
+            seen_timestamp,
+            cx,
+            chain_hash_opt,
+            lookup,
+        ) {
+            Ok(lookup) => {
+                self.single_block_lookups.insert(id, lookup);
+            }
+            Err(e) => {
+                debug!(self.log,
+                    "Single lookup retry failed";
+                    "error" => ?e,
+                    "block_root" => ?expected_block_root,
+                );
+            }
+        }
 
-        let request_state = R::request_state_mut(lookup);
+        metrics::set_gauge(
+            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
+            self.single_block_lookups.len() as i64,
+        );
+    }
+
+    /// Consolidates error handling for `single_lookup_response`. An `Err` here should always mean
+    /// the lookup is dropped.
+    fn single_lookup_response_inner<R: RequestState<Current, T>>(
+        &self,
+        peer_id: PeerId,
+        response: Option<R::ResponseType>,
+        seen_timestamp: Duration,
+        cx: &SyncNetworkContext<T>,
+        delay_send: bool,
+        mut lookup: SingleBlockLookup<Current, T>,
+    ) -> Result<SingleBlockLookup<Current, T>, LookupRequestError> {
+        let response_type = R::response_type();
+        let log = self.log.clone();
+        let expected_block_root = lookup.block_root();
+        let request_state = R::request_state_mut(&mut lookup);
 
         match request_state.verify_response(expected_block_root, response) {
-            Ok(Some((root, verified_response))) => {
-                if let Some(parent_components) = lookup.unknown_parent_components.as_mut() {
-                    R::add_to_parent_components(verified_response, parent_components);
-
-                    if !has_pending_parent_request {
-                        if let Some(rpc_block) = lookup.get_downloaded_block() {
-                            if let Err(()) = self.send_block_for_processing(
-                                expected_block_root,
-                                rpc_block,
-                                seen_timestamp,
-                                BlockProcessType::SingleBlock { id },
-                                cx,
-                            ) {
-                                self.single_block_lookups.remove(&id);
-                            }
-                        }
-                    }
-                } else if let Err(()) = R::send_for_processing(
-                    id,
-                    self,
-                    root,
-                    R::verified_to_reconstructed(verified_response),
+            Ok(Some(verified_response)) => {
+                self.handle_verified_response::<Current, R>(
                     seen_timestamp,
                     cx,
-                ) {
-                    self.single_block_lookups.remove(&id);
-                }
+                    delay_send,
+                    None,
+                    verified_response,
+                    &mut lookup,
+                )?;
             }
             Ok(None) => {}
             Err(e) => {
-                let msg = if matches!(e, LookupVerifyError::BenignFailure) {
+                debug!(
+                    log,
+                    "Single lookup response verification failed, retrying";
+                    "block_root" => ?expected_block_root,
+                    "peer_id" => %peer_id,
+                    "response_type" => ?response_type,
+                    "error" => ?e
+                );
+                if matches!(e, LookupVerifyError::BenignFailure) {
                     request_state
                         .get_state_mut()
                         .remove_peer_if_useless(&peer_id);
-                    "peer could not response to request"
                 } else {
                     let msg = e.into();
                     cx.report_peer(peer_id, PeerAction::LowToleranceError, msg);
-                    msg
                 };
 
-                debug!(log, "Single block lookup failed";
-                    "peer_id" => %peer_id,
-                    "error" => msg,
-                    "block_root" => ?expected_block_root,
-                    "response_type" => ?response_type
-                );
-                if let Err(()) = request_state.retry_request_after_failure(id, cx, &log) {
-                    self.single_block_lookups.remove(&id);
+                request_state.register_failure_downloading();
+                lookup.request_block_and_blobs(cx)?;
+            }
+        }
+        Ok(lookup)
+    }
+
+    fn handle_verified_response<L: Lookup, R: RequestState<L, T>>(
+        &self,
+        seen_timestamp: Duration,
+        cx: &SyncNetworkContext<T>,
+        delay_send: bool,
+        chain_hash: Option<Hash256>,
+        verified_response: R::VerifiedResponseType,
+        lookup: &mut SingleBlockLookup<L, T>,
+    ) -> Result<(), LookupRequestError> {
+        let id = lookup.id;
+        let block_root = lookup.block_root();
+
+        R::request_state_mut(lookup)
+            .get_state_mut()
+            .component_downloaded = true;
+
+        let cached_child = lookup.add_response::<R>(verified_response.clone());
+
+        match cached_child {
+            CachedChild::Ok(block) => {
+                if let Some(chain_hash) = chain_hash {
+                    if !delay_send {
+                        let process_type = match L::lookup_type() {
+                            LookupType::Parent => BlockProcessType::ParentLookup { chain_hash },
+                            LookupType::Current => BlockProcessType::SingleBlock { id },
+                        };
+                        self.send_block_for_processing(
+                            block_root,
+                            block,
+                            seen_timestamp,
+                            process_type,
+                            cx,
+                        )?
+                    }
+                }
+            }
+            CachedChild::DownloadIncomplete => {
+                // If this was the result of a block request, we can't determined if the block peer
+                // did anything wrong. If we already had both a block and blobs response processed,
+                // we should penalize the blobs peer because they did not provide all blobs on the
+                // initial request.
+                if lookup.both_components_downloaded() {
+                    lookup.penalize_lazy_blob_peer(cx);
+                    lookup
+                        .blob_request_state
+                        .state
+                        .register_failure_downloading();
                 }
+                lookup.request_block_and_blobs(cx)?;
+            }
+            CachedChild::NotRequired => R::send_for_processing(
+                id,
+                self,
+                block_root,
+                R::verified_to_reconstructed(verified_response),
+                seen_timestamp,
+                cx,
+            )?,
+            CachedChild::Err(e) => {
+                warn!(self.log, "Consistency error in cached block";
+                    "error" => ?e,
+                    "block_root" => ?block_root
+                );
+                lookup.handle_consistency_failure(cx);
+                lookup.request_block_and_blobs(cx)?;
             }
         }
+        Ok(())
+    }
 
-        //TODO(sean) move metric to trait to differentiate block and blob
-        metrics::set_gauge(
-            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
-            self.single_block_lookups.len() as i64,
-        );
+    /// Get a parent block lookup by its ID. This method additionally ensures the `req_counter`
+    /// matches the current `req_counter` for the lookup. This any stale responses from requests
+    /// that have been retried are ignored.
+    fn get_parent_lookup<R: RequestState<Parent, T>>(
+        &mut self,
+        id: SingleLookupReqId,
+    ) -> Option<ParentLookup<T>> {
+        let mut parent_lookup = if let Some(pos) = self
+            .parent_lookups
+            .iter()
+            .position(|request| request.current_parent_request.id == id.id)
+        {
+            self.parent_lookups.remove(pos)
+        } else {
+            return None;
+        };
+
+        if R::request_state_mut(&mut parent_lookup.current_parent_request)
+            .get_state()
+            .req_counter
+            != id.req_counter
+        {
+            self.parent_lookups.push(parent_lookup);
+            return None;
+        }
+        Some(parent_lookup)
     }
 
     /// Process a response received from a parent lookup request.
     pub fn parent_lookup_response<R: RequestState<Parent, T>>(
         &mut self,
-        id: Id,
+        id: SingleLookupReqId,
         peer_id: PeerId,
-        block: Option<R::ResponseType>,
+        response: Option<R::ResponseType>,
         seen_timestamp: Duration,
         cx: &SyncNetworkContext<T>,
     ) {
-        let mut parent_lookup = if let Some(pos) = self
-            .parent_lookups
-            .iter()
-            .position(|request| request.current_parent_request.id == id)
-        {
-            self.parent_lookups.remove(pos)
-        } else {
-            if block.is_some() {
+        let Some(mut parent_lookup) = self.get_parent_lookup::<R>(id) else {
+            if response.is_some() {
                 debug!(self.log, "Response for a parent lookup request that was not found"; "peer_id" => %peer_id);
             }
-            return;
+            return
         };
 
-        match parent_lookup.verify_block::<R>(block, &mut self.failed_chains) {
-            Ok(Some((block_root, verified_response))) => {
-                if let Some(parent_components) = parent_lookup
-                    .current_parent_request
-                    .unknown_parent_components
-                    .as_mut()
-                {
-                    R::add_to_parent_components(verified_response, parent_components);
-                }
-                if let Some(rpc_block) = parent_lookup.current_parent_request.get_downloaded_block()
-                {
-                    let chain_hash = parent_lookup.chain_hash();
-                    if self
-                        .send_block_for_processing(
-                            block_root,
-                            rpc_block,
-                            seen_timestamp,
-                            BlockProcessType::ParentLookup { chain_hash },
-                            cx,
-                        )
-                        .is_ok()
-                    {
-                        self.parent_lookups.push(parent_lookup)
-                    }
-                } else {
-                    //TODO(sean) here, we could penalize a peer who previously sent us a blob list
-                    // that was incomplete, and trigger a re-request immediately
-                    self.parent_lookups.push(parent_lookup)
-                }
-            }
-            Ok(None) => {
-                // Request finished successfully, nothing else to do. It will be removed after the
-                // processing result arrives.
+        match self.parent_lookup_response_inner::<R>(
+            peer_id,
+            response,
+            seen_timestamp,
+            cx,
+            &mut parent_lookup,
+        ) {
+            Ok(()) => {
+                debug!(self.log, "Requesting parent"; &parent_lookup);
                 self.parent_lookups.push(parent_lookup);
             }
-            Err(e) => self.handle_parent_verify_error::<R>(peer_id, parent_lookup, e, cx),
-        };
+            Err(e) => {
+                self.handle_parent_request_error(&mut parent_lookup, cx, e);
+            }
+        }
 
-        //TODO(sean) move metric to trait to differentiate block and blob
         metrics::set_gauge(
             &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
             self.parent_lookups.len() as i64,
         );
     }
 
+    /// Consolidates error handling for `parent_lookup_response`. An `Err` here should always mean
+    /// the lookup is dropped.
+    fn parent_lookup_response_inner<R: RequestState<Parent, T>>(
+        &mut self,
+        peer_id: PeerId,
+        block: Option<R::ResponseType>,
+        seen_timestamp: Duration,
+        cx: &SyncNetworkContext<T>,
+        parent_lookup: &mut ParentLookup<T>,
+    ) -> Result<(), RequestError> {
+        match parent_lookup.verify_block::<R>(block, &mut self.failed_chains) {
+            Ok(Some(verified_response)) => {
+                self.handle_verified_response::<Parent, R>(
+                    seen_timestamp,
+                    cx,
+                    false,
+                    Some(parent_lookup.chain_hash()),
+                    verified_response,
+                    &mut parent_lookup.current_parent_request,
+                )?;
+            }
+            Ok(None) => {}
+            Err(e) => self.handle_parent_verify_error::<R>(peer_id, parent_lookup, e, cx)?,
+        };
+        Ok(())
+    }
+
+    /// Handle logging and peer scoring for `ParentVerifyError`s during parent lookup requests.
     fn handle_parent_verify_error<R: RequestState<Parent, T>>(
         &mut self,
         peer_id: PeerId,
-        mut parent_lookup: ParentLookup<T>,
+        parent_lookup: &mut ParentLookup<T>,
         e: ParentVerifyError,
         cx: &SyncNetworkContext<T>,
-    ) {
+    ) -> Result<(), RequestError> {
         match e {
             ParentVerifyError::RootMismatch
             | ParentVerifyError::NoBlockReturned
@@ -520,7 +665,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 cx.report_peer(peer_id, PeerAction::LowToleranceError, e);
 
                 // We try again if possible.
-                self.request_parent(parent_lookup, cx)
+                parent_lookup.request_parent(cx)?;
             }
             ParentVerifyError::PreviousFailure { parent_root } => {
                 debug!(
@@ -544,7 +689,47 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 );
                 let request_state = R::request_state_mut(&mut parent_lookup.current_parent_request);
                 request_state.remove_if_useless(&peer_id);
-                self.request_parent(parent_lookup, cx)
+                parent_lookup.request_parent(cx)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Handle logging and peer scoring for `RequestError`s during parent lookup requests.
+    fn handle_parent_request_error(
+        &mut self,
+        parent_lookup: &mut ParentLookup<T>,
+        cx: &SyncNetworkContext<T>,
+        e: RequestError,
+    ) {
+        debug!(self.log, "Failed to request parent";  "error" => e.as_static());
+        match e {
+            RequestError::SendFailed(_) => {
+                // Probably shutting down, nothing to do here. Drop the request
+            }
+            RequestError::ChainTooLong => {
+                self.failed_chains.insert(parent_lookup.chain_hash());
+                // This indicates faulty peers.
+                for &peer_id in parent_lookup.used_peers() {
+                    cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
+                }
+            }
+            RequestError::TooManyAttempts { cannot_process } => {
+                // We only consider the chain failed if we were unable to process it.
+                // We could have failed because one peer continually failed to send us
+                // bad blocks. We still allow other peers to send us this chain. Note
+                // that peers that do this, still get penalised.
+                if cannot_process {
+                    self.failed_chains.insert(parent_lookup.chain_hash());
+                }
+                // This indicates faulty peers.
+                for &peer_id in parent_lookup.used_peers() {
+                    cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
+                }
+            }
+            RequestError::NoPeers => {
+                // This happens if the peer disconnects while the block is being
+                // processed. Drop the request without extra penalty
             }
         }
     }
@@ -553,18 +738,19 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
 
     pub fn peer_disconnected(&mut self, peer_id: &PeerId, cx: &mut SyncNetworkContext<T>) {
         /* Check disconnection for single lookups */
-        self.single_block_lookups.retain(|id, req| {
-            let should_remove_lookup =
-                req.should_remove_disconnected_peer(*id, peer_id, cx, &self.log);
+        self.single_block_lookups.retain(|_, req| {
+            let should_drop_lookup =
+                req.should_drop_lookup_on_disconnected_peer(peer_id, cx, &self.log);
 
-            !should_remove_lookup
+            !should_drop_lookup
         });
 
         /* Check disconnection for parent lookups */
-        while let Some(pos) = self.parent_lookups.iter_mut().position(|req| {
-            req.check_block_peer_disconnected(peer_id).is_err()
-                || req.check_blob_peer_disconnected(peer_id).is_err()
-        }) {
+        while let Some(pos) = self
+            .parent_lookups
+            .iter_mut()
+            .position(|req| req.check_peer_disconnected(peer_id).is_err())
+        {
             let parent_lookup = self.parent_lookups.remove(pos);
             trace!(self.log, "Parent lookup's peer disconnected"; &parent_lookup);
             self.request_parent(parent_lookup, cx);
@@ -574,26 +760,25 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     /// An RPC error has occurred during a parent lookup. This function handles this case.
     pub fn parent_lookup_failed<R: RequestState<Parent, T>>(
         &mut self,
-        id: Id,
+        id: SingleLookupReqId,
         peer_id: PeerId,
         cx: &SyncNetworkContext<T>,
         error: RPCError,
     ) {
         let msg = error.as_static_str();
-        if let Some(pos) = self
-            .parent_lookups
-            .iter()
-            .position(|request| request.current_parent_request.id == id)
-        {
-            let mut parent_lookup = self.parent_lookups.remove(pos);
-            R::request_state_mut(&mut parent_lookup.current_parent_request)
-                .register_failure_downloading();
-            trace!(self.log, "Parent lookup block request failed"; &parent_lookup, "error" => msg);
-
-            self.request_parent(parent_lookup, cx);
-        } else {
-            return debug!(self.log, "RPC failure for a block parent lookup request that was not found"; "peer_id" => %peer_id, "error" => msg);
+        let Some(mut parent_lookup) = self.get_parent_lookup::<R>(id) else {
+            debug!(self.log,
+                "RPC failure for a block parent lookup request that was not found";
+                "peer_id" => %peer_id,
+                "error" => msg
+            );
+            return
         };
+        R::request_state_mut(&mut parent_lookup.current_parent_request)
+            .register_failure_downloading();
+        trace!(self.log, "Parent lookup block request failed"; &parent_lookup, "error" => msg);
+
+        self.request_parent(parent_lookup, cx);
 
         metrics::set_gauge(
             &metrics::SYNC_PARENT_BLOCK_LOOKUPS,
@@ -601,32 +786,40 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         );
     }
 
+    /// An RPC error has occurred during a single lookup. This function handles this case.\
     pub fn single_block_lookup_failed<R: RequestState<Current, T>>(
         &mut self,
-        id: Id,
+        id: SingleLookupReqId,
         peer_id: &PeerId,
         cx: &SyncNetworkContext<T>,
         error: RPCError,
     ) {
         let msg = error.as_static_str();
-        let Some(lookup) = self.single_block_lookups.get_mut(&id) else {
-            debug!(self.log, "Error response to dropped lookup"; "error" => ?error);
+        let log = self.log.clone();
+        let Some(mut lookup) = self.get_single_lookup::<R>(id) else {
+            debug!(log, "Error response to dropped lookup"; "error" => ?error);
             return;
         };
-        let root = lookup.block_request_state.requested_block_root;
-        let request_state = R::request_state_mut(lookup);
-        request_state.register_failure_downloading();
+        let block_root = lookup.block_root();
+        let request_state = R::request_state_mut(&mut lookup);
         let response_type = R::response_type();
-        trace!(self.log,
+        trace!(log,
             "Single lookup failed";
-            "block_root" => ?root,
+            "block_root" => ?block_root,
             "error" => msg,
             "peer_id" => %peer_id,
             "response_type" => ?response_type
         );
-        if let Err(()) = request_state.retry_request_after_failure(id, cx, &self.log) {
+        let id = id.id;
+        request_state.register_failure_downloading();
+        if let Err(e) = lookup.request_block_and_blobs(cx) {
+            debug!(self.log,
+                "Single lookup retry failed";
+                "error" => ?e,
+                "block_root" => ?block_root,
+            );
             self.single_block_lookups.remove(&id);
-        };
+        }
 
         metrics::set_gauge(
             &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
@@ -642,64 +835,35 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         result: BlockProcessingResult<T::EthSpec>,
         cx: &mut SyncNetworkContext<T>,
     ) {
-        let Some(request_ref) = self.single_block_lookups.get_mut(&target_id) else {
-           debug!(self.log, "Block component processed for single block lookup not present"    );
+        let Some(mut lookup) = self.single_block_lookups.remove(&target_id) else {
            return;
        };
 
-        let root = request_ref.block_request_state.requested_block_root;
-        let request_state = R::request_state_mut(request_ref);
-        let peer_id = request_state.get_state().processing_peer();
-        request_state.get_state_mut().component_processed = true;
+        let root = lookup.block_root();
+        let request_state = R::request_state_mut(&mut lookup);
 
-        let peer_id = match peer_id {
-            Ok(peer) => peer,
-            Err(_) => return,
+        let Ok(peer_id)  = request_state.get_state().processing_peer() else {
+           return
         };
+        debug!(
+            self.log,
+            "Block component processed for single block lookup not present"
+        );
 
         match result {
             BlockProcessingResult::Ok(status) => match status {
                 AvailabilityProcessingStatus::Imported(root) => {
                     trace!(self.log, "Single block processing succeeded"; "block" => %root);
-                    self.single_block_lookups.remove(&target_id);
                 }
                 AvailabilityProcessingStatus::MissingComponents(_, _block_root) => {
-                    // if this was the result of a blocks request, the block peer did nothing wrong.
-                    // if we already had a blobs resposne, we should penalize the blobs peer because
-                    // they did not provide all blobs.
-                    if request_ref.both_components_processed() {
-                        if let Ok(blob_peer) =
-                            request_ref.blob_request_state.state.processing_peer()
-                        {
-                            if let PeerShouldHave::BlockAndBlobs(blob_peer) = blob_peer {
-                                cx.report_peer(
-                                    blob_peer,
-                                    PeerAction::MidToleranceError,
-                                    "single_block_failure",
-                                );
-                            }
-                            request_ref
-                                .blob_request_state
-                                .state
-                                .remove_peer_if_useless(blob_peer.as_peer_id());
-                            if !<BlobRequestState<
-                                single_block_lookup::Current,
-                                <T as BeaconChainTypes>::EthSpec,
-                            > as RequestState<single_block_lookup::Current, T>>::downloading(
-                                &request_ref.blob_request_state,
-                            ) {
-                                // Try it again if possible.
-                                if let Err(()) = request_ref
-                                    .blob_request_state
-                                    .retry_request_after_failure(target_id, cx, &self.log)
-                                {
-                                    self.single_block_lookups.remove(&target_id);
-                                };
-                            }
-                        } else {
-                            trace!(self.log, "Dropped blob peer prior to penalizing"; "root" => ?root);
-                            self.single_block_lookups.remove(&target_id);
-                        };
+                    match self.handle_missing_components::<R>(cx, &mut lookup) {
+                        Ok(()) => {
+                            self.single_block_lookups.insert(target_id, lookup);
+                        }
+                        Err(e) => {
+                            // Drop with an additional error.
+                            warn!(self.log, "Single block lookup failed"; "block" => %root, "error" => ?e);
+                        }
                     }
                 }
             },
@@ -711,89 +875,132 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     "Single block processing was ignored, cpu might be overloaded";
                     "action" => "dropping single block request"
                 );
-                self.single_block_lookups.remove(&target_id);
             }
             BlockProcessingResult::Err(e) => {
-                trace!(self.log, "Single block processing failed"; "block" => %root, "error" => %e);
-                match e {
-                    BlockError::BlockIsAlreadyKnown => {
-                        // No error here
-                        self.single_block_lookups.remove(&target_id);
-                    }
-                    BlockError::BeaconChainError(e) => {
-                        // Internal error
-                        error!(self.log, "Beacon chain error processing single block"; "block_root" => %root, "error" => ?e);
-                        self.single_block_lookups.remove(&target_id);
+                match self.handle_single_lookup_block_error(cx, lookup, peer_id, e) {
+                    Ok(Some(lookup)) => {
+                        self.single_block_lookups.insert(target_id, lookup);
                     }
-                    BlockError::ParentUnknown(block) => {
-                        let slot = block.slot();
-                        let parent_root = block.parent_root();
-                        request_ref.add_unknown_parent_components(block.into());
-                        self.search_parent(slot, root, parent_root, peer_id.to_peer_id(), cx);
+                    Ok(None) => {
+                        // Drop without an additional error.
                     }
-                    ref e @ BlockError::ExecutionPayloadError(ref epe) if !epe.penalize_peer() => {
-                        // These errors indicate that the execution layer is offline
-                        // and failed to validate the execution payload. Do not downscore peer.
-                        debug!(
-                            self.log,
-                            "Single block lookup failed. Execution layer is offline / unsynced / misconfigured";
-                            "root" => %root,
-                            "error" => ?e
-                        );
-                        self.single_block_lookups.remove(&target_id);
-                    }
-                    BlockError::AvailabilityCheck(
-                        AvailabilityCheckError::KzgVerificationFailed,
-                    )
-                    | BlockError::AvailabilityCheck(AvailabilityCheckError::Kzg(_))
-                    | BlockError::BlobValidation(_) => {
-                        warn!(self.log, "Blob validation failure"; "root" => %root, "peer_id" => %peer_id);
-                        if let Ok(blob_peer) =
-                            request_ref.blob_request_state.state.processing_peer()
-                        {
-                            cx.report_peer(
-                                blob_peer.to_peer_id(),
-                                PeerAction::MidToleranceError,
-                                "single_blob_failure",
-                            );
-                            // Try it again if possible.
-                            if let Err(()) = request_ref
-                                .blob_request_state
-                                .retry_request_after_failure(target_id, cx, &self.log)
-                            {
-                                self.single_block_lookups.remove(&target_id);
-                            };
-                        }
-                    }
-                    other => {
-                        warn!(self.log, "Peer sent invalid block in single block lookup"; "root" => %root, "error" => ?other, "peer_id" => %peer_id);
-                        if let Ok(block_peer) =
-                            request_ref.block_request_state.state.processing_peer()
-                        {
-                            cx.report_peer(
-                                block_peer.to_peer_id(),
-                                PeerAction::MidToleranceError,
-                                "single_block_failure",
-                            );
-
-                            // Try it again if possible.
-                            if let Err(()) = request_ref
-                                .blob_request_state
-                                .retry_request_after_failure(target_id, cx, &self.log)
-                            {
-                                self.single_block_lookups.remove(&target_id);
-                            };
-                        }
+                    Err(e) => {
+                        // Drop with an additional error.
+                        warn!(self.log, "Single block lookup failed"; "block" => %root, "error" => ?e);
                     }
                 }
             }
         };
+    }
 
-        //TODO(sean) move metrics to lookup response trait
-        metrics::set_gauge(
-            &metrics::SYNC_SINGLE_BLOCK_LOOKUPS,
-            self.single_block_lookups.len() as i64,
-        );
+    /// Handles a `MissingComponents` block processing error. Handles peer scoring and retries.
+    ///
+    /// If this was the result of a block request, we can't determined if the block peer did anything
+    /// wrong. If we already had both a block and blobs response processed, we should penalize the
+    /// blobs peer because they did not provide all blobs on the initial request.
+    fn handle_missing_components<R: RequestState<Current, T>>(
+        &self,
+        cx: &mut SyncNetworkContext<T>,
+        lookup: &mut SingleBlockLookup<Current, T>,
+    ) -> Result<(), LookupRequestError> {
+        let request_state = R::request_state_mut(lookup);
+
+        request_state.get_state_mut().component_processed = true;
+        if lookup.both_components_processed() {
+            lookup.penalize_lazy_blob_peer(cx);
+
+            // Try it again if possible.
+            lookup
+                .blob_request_state
+                .state
+                .register_failure_processing();
+            lookup.request_block_and_blobs(cx)?;
+        }
+        Ok(())
+    }
+
+    /// Handles peer scoring and retries related to a `BlockError` in response to a single block
+    /// or blob lookup processing result.
+    fn handle_single_lookup_block_error(
+        &mut self,
+        cx: &mut SyncNetworkContext<T>,
+        mut lookup: SingleBlockLookup<Current, T>,
+        peer_id: PeerShouldHave,
+        e: BlockError<T::EthSpec>,
+    ) -> Result<Option<SingleBlockLookup<Current, T>>, LookupRequestError> {
+        let root = lookup.block_root();
+        trace!(self.log, "Single block processing failed"; "block" => %root, "error" => %e);
+        match e {
+            BlockError::BlockIsAlreadyKnown => {
+                // No error here
+                return Ok(None);
+            }
+            BlockError::BeaconChainError(e) => {
+                // Internal error
+                error!(self.log, "Beacon chain error processing single block"; "block_root" => %root, "error" => ?e);
+                return Ok(None);
+            }
+            BlockError::ParentUnknown(block) => {
+                let slot = block.slot();
+                let parent_root = block.parent_root();
+                lookup.add_child_components(block.into());
+                lookup.request_block_and_blobs(cx)?;
+                self.search_parent(slot, root, parent_root, peer_id.to_peer_id(), cx);
+            }
+            ref e @ BlockError::ExecutionPayloadError(ref epe) if !epe.penalize_peer() => {
+                // These errors indicate that the execution layer is offline
+                // and failed to validate the execution payload. Do not downscore peer.
+                debug!(
+                    self.log,
+                    "Single block lookup failed. Execution layer is offline / unsynced / misconfigured";
+                    "root" => %root,
+                    "error" => ?e
+                );
+                return Ok(None);
+            }
+            BlockError::AvailabilityCheck(e) => {
+                warn!(self.log, "Availability check failure"; "root" => %root, "peer_id" => %peer_id, "error" => ?e);
+                lookup.handle_availability_check_failure(cx);
+                lookup.request_block_and_blobs(cx)?
+            }
+            BlockError::BlobValidation(_) => {
+                warn!(self.log, "Blob validation failure"; "root" => %root, "peer_id" => %peer_id);
+                if let Ok(blob_peer) = lookup.blob_request_state.state.processing_peer() {
+                    cx.report_peer(
+                        blob_peer.to_peer_id(),
+                        PeerAction::MidToleranceError,
+                        "single_block_failure",
+                    );
+                    lookup
+                        .blob_request_state
+                        .state
+                        .remove_peer_if_useless(blob_peer.as_peer_id());
+                }
+                lookup
+                    .blob_request_state
+                    .state
+                    .register_failure_processing();
+                lookup.request_block_and_blobs(cx)?
+            }
+            other => {
+                warn!(self.log, "Peer sent invalid block in single block lookup"; "root" => %root, "error" => ?other, "peer_id" => %peer_id);
+                if let Ok(block_peer) = lookup.block_request_state.state.processing_peer() {
+                    cx.report_peer(
+                        block_peer.to_peer_id(),
+                        PeerAction::MidToleranceError,
+                        "single_block_failure",
+                    );
+
+                    // Try it again if possible.
+                    lookup
+                        .block_request_state
+                        .state
+                        .register_failure_processing();
+                    lookup.request_block_and_blobs(cx)?
+                }
+            }
+        }
+        Ok(Some(lookup))
     }
 
     pub fn parent_block_processed(
@@ -813,11 +1020,6 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             return debug!(self.log, "Process response for a parent lookup request that was not found"; "chain_hash" => %chain_hash);
         };
 
-        let Ok(peer_id) =
-            parent_lookup.processing_peer() else {
-            return
-        };
-
         match &result {
             BlockProcessingResult::Ok(status) => match status {
                 AvailabilityProcessingStatus::Imported(block_root) => {
@@ -845,7 +1047,32 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 _,
                 block_root,
             )) => {
-                self.search_block(block_root, peer_id, cx);
+                let expected_block_root = parent_lookup.current_parent_request.block_root();
+                if block_root != expected_block_root {
+                    warn!(
+                        self.log,
+                        "Parent block processing result/request root mismatch";
+                        "request" =>?expected_block_root,
+                        "result" => ?block_root
+                    );
+                    return;
+                }
+
+                // We only send parent blocks + blobs for processing together. This means a
+                // `MissingComponents` response here indicates missing blobs. Therefore we always
+                // register a blob processing failure here.
+                parent_lookup
+                    .current_parent_request
+                    .blob_request_state
+                    .state
+                    .register_failure_processing();
+                match parent_lookup
+                    .current_parent_request
+                    .request_block_and_blobs(cx)
+                {
+                    Ok(()) => self.parent_lookups.push(parent_lookup),
+                    Err(e) => self.handle_parent_request_error(&mut parent_lookup, cx, e.into()),
+                }
             }
             BlockProcessingResult::Err(BlockError::ParentUnknown(block)) => {
                 parent_lookup.add_unknown_parent_block(block);
@@ -864,29 +1091,10 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                         );
                     }
                 };
-                let (chain_hash, mut blocks, hashes, block_request) =
+                let (chain_hash, blocks, hashes, block_request) =
                     parent_lookup.parts_for_processing();
 
-                // Find the child block that spawned the parent lookup request and add it to the chain
-                // to send for processing.
-                if let Some(child_lookup_id) =
-                    self.single_block_lookups.iter().find_map(|(id, lookup)| {
-                        (lookup.block_request_state.requested_block_root == chain_hash)
-                            .then_some(*id)
-                    })
-                {
-                    let Some(child_lookup) = self.single_block_lookups.get_mut(&child_lookup_id)  else {
-                        debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
-                        return;
-                    };
-                    if let Some(rpc_block) = child_lookup.get_downloaded_block() {
-                        blocks.push(rpc_block);
-                    } else {
-                        trace!(self.log, "Parent lookup chain complete, awaiting child response"; "chain_hash" => ?chain_hash);
-                    }
-                } else {
-                    debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
-                };
+                let blocks = self.add_child_block_to_chain(chain_hash, blocks, cx);
 
                 let process_id = ChainSegmentProcessId::ParentLookup(chain_hash);
 
@@ -917,7 +1125,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 );
             }
             BlockProcessingResult::Err(outcome) => {
-                self.handle_invalid_block(outcome, peer_id.to_peer_id(), cx, parent_lookup);
+                self.handle_parent_block_error(outcome, cx, parent_lookup);
             }
             BlockProcessingResult::Ignored => {
                 // Beacon processor signalled to ignore the block processing result.
@@ -936,24 +1144,107 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         );
     }
 
-    fn handle_invalid_block(
+    /// Find the child block that spawned the parent lookup request and add it to the chain
+    /// to send for processing.
+    fn add_child_block_to_chain(
+        &mut self,
+        chain_hash: Hash256,
+        mut blocks: Vec<RpcBlock<T::EthSpec>>,
+        cx: &SyncNetworkContext<T>,
+    ) -> Vec<RpcBlock<T::EthSpec>> {
+        // Find the child block that spawned the parent lookup request and add it to the chain
+        // to send for processing.
+        if let Some(child_lookup_id) = self
+            .single_block_lookups
+            .iter()
+            .find_map(|(id, lookup)| (lookup.block_root() == chain_hash).then_some(*id))
+        {
+            let Some(child_lookup) = self.single_block_lookups.get_mut(&child_lookup_id)  else {
+                debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
+                return blocks;
+            };
+            match child_lookup.get_cached_child_block() {
+                CachedChild::Ok(rpc_block) => {
+                    blocks.push(rpc_block);
+                }
+                CachedChild::DownloadIncomplete => {
+                    trace!(self.log, "Parent lookup chain complete, awaiting child response"; "chain_hash" => ?chain_hash);
+                }
+                CachedChild::NotRequired => {
+                    warn!(self.log, "Child not cached for parent lookup"; "chain_hash" => %chain_hash);
+                }
+                CachedChild::Err(e) => {
+                    warn!(
+                        self.log,
+                        "Consistency error in child block triggering chain or parent lookups";
+                        "error" => ?e,
+                        "chain_hash" => ?chain_hash
+                    );
+                    child_lookup.handle_consistency_failure(cx);
+                    if child_lookup.request_block_and_blobs(cx).is_err() {
+                        self.single_block_lookups.remove(&child_lookup_id);
+                    }
+                }
+            }
+        } else {
+            debug!(self.log, "Missing child for parent lookup request"; "child_root" => ?chain_hash);
+        };
+        blocks
+    }
+
+    /// Handle the peer scoring, retries, and logging related to a `BlockError` returned from
+    /// processing a block + blobs for a parent lookup.
+    fn handle_parent_block_error(
         &mut self,
         outcome: BlockError<<T as BeaconChainTypes>::EthSpec>,
-        peer_id: PeerId,
         cx: &SyncNetworkContext<T>,
         mut parent_lookup: ParentLookup<T>,
     ) {
+        // We should always have a block peer.
+        let Ok(block_peer_id) =
+            parent_lookup.block_processing_peer() else {
+            return
+        };
+        let block_peer_id = block_peer_id.to_peer_id();
+
+        // We may not have a blob peer, if there were no blobs required for this block.
+        let blob_peer_id = parent_lookup
+            .blob_processing_peer()
+            .ok()
+            .map(PeerShouldHave::to_peer_id);
+
         // all else we consider the chain a failure and downvote the peer that sent
         // us the last block
         warn!(
             self.log, "Invalid parent chain";
             "score_adjustment" => %PeerAction::MidToleranceError,
             "outcome" => ?outcome,
-            "last_peer" => %peer_id,
+            "block_peer_id" => %block_peer_id,
         );
         // This currently can be a host of errors. We permit this due to the partial
         // ambiguity.
-        cx.report_peer(peer_id, PeerAction::MidToleranceError, "parent_request_err");
+        cx.report_peer(
+            block_peer_id,
+            PeerAction::MidToleranceError,
+            "parent_request_err",
+        );
+        // Don't downscore the same peer twice
+        if let Some(blob_peer_id) = blob_peer_id {
+            if block_peer_id != blob_peer_id {
+                debug!(
+                    self.log, "Additionally down-scoring blob peer";
+                    "score_adjustment" => %PeerAction::MidToleranceError,
+                    "outcome" => ?outcome,
+                    "blob_peer_id" => %blob_peer_id,
+                );
+                cx.report_peer(
+                    blob_peer_id,
+                    PeerAction::MidToleranceError,
+                    "parent_request_err",
+                );
+            }
+        }
+
         // Try again if possible
         parent_lookup.processing_failed();
         self.request_parent(parent_lookup, cx);
@@ -979,7 +1270,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     .single_block_lookups
                     .iter()
                     .find_map(|(id, req)|
-                        (req.block_request_state.requested_block_root == chain_hash).then_some(*id)) else {
+                        (req.block_root() == chain_hash).then_some(*id)) else {
                     warn!(self.log, "No id found for single block lookup"; "chain_hash" => %chain_hash);
                     return;
                 };
@@ -991,20 +1282,40 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                     return;
                 };
 
-                if let Some(rpc_block) = lookup.get_downloaded_block() {
-                    // This is the correct block, send it for processing
-                    if self
-                        .send_block_for_processing(
-                            chain_hash,
-                            rpc_block,
-                            Duration::from_secs(0), //TODO(sean) pipe this through
-                            BlockProcessType::SingleBlock { id },
-                            cx,
-                        )
-                        .is_err()
-                    {
-                        // Remove to avoid inconsistencies
-                        self.single_block_lookups.remove(&id);
+                match lookup.get_cached_child_block() {
+                    CachedChild::Ok(rpc_block) => {
+                        // This is the correct block, send it for processing
+                        if self
+                            .send_block_for_processing(
+                                chain_hash,
+                                rpc_block,
+                                timestamp_now(),
+                                BlockProcessType::SingleBlock { id },
+                                cx,
+                            )
+                            .is_err()
+                        {
+                            // Remove to avoid inconsistencies
+                            self.single_block_lookups.remove(&id);
+                        }
+                    }
+                    CachedChild::DownloadIncomplete => {
+                        trace!(self.log, "Parent chain complete, awaiting child response"; "chain_hash" => %chain_hash);
+                    }
+                    CachedChild::NotRequired => {
+                        warn!(self.log, "Child not cached for parent lookup"; "chain_hash" => %chain_hash);
+                    }
+                    CachedChild::Err(e) => {
+                        warn!(
+                            self.log,
+                            "Consistency error in child block triggering parent lookup";
+                            "chain_hash" => %chain_hash,
+                            "error" => ?e
+                        );
+                        lookup.handle_consistency_failure(cx);
+                        if lookup.request_block_and_blobs(cx).is_err() {
+                            self.single_block_lookups.remove(&id);
+                        }
                     }
                 }
             }
@@ -1013,9 +1324,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 penalty,
             } => {
                 self.failed_chains.insert(chain_hash);
-                let mut all_peers = request.block_request_state.state.used_peers.clone();
-                all_peers.extend(request.blob_request_state.state.used_peers);
-                for peer_source in all_peers {
+                for peer_source in request.all_peers() {
                     cx.report_peer(peer_source, penalty, "parent_chain_failure")
                 }
             }
@@ -1033,13 +1342,13 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     /* Helper functions */
 
     fn send_block_for_processing(
-        &mut self,
+        &self,
         block_root: Hash256,
         block: RpcBlock<T::EthSpec>,
         duration: Duration,
         process_type: BlockProcessType,
         cx: &SyncNetworkContext<T>,
-    ) -> Result<(), ()> {
+    ) -> Result<(), LookupRequestError> {
         match cx.beacon_processor_if_enabled() {
             Some(beacon_processor) => {
                 trace!(self.log, "Sending block for processing"; "block" => ?block_root, "process" => ?process_type);
@@ -1054,14 +1363,18 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                         "Failed to send sync block to processor";
                         "error" => ?e
                     );
-                    Err(())
+                    Err(LookupRequestError::SendFailed(
+                        "beacon processor send failure",
+                    ))
                 } else {
                     Ok(())
                 }
             }
             None => {
                 trace!(self.log, "Dropping block ready for processing. Beacon processor not available"; "block" => %block_root);
-                Err(())
+                Err(LookupRequestError::SendFailed(
+                    "beacon processor unavailable",
+                ))
             }
         }
     }
@@ -1073,11 +1386,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         duration: Duration,
         process_type: BlockProcessType,
         cx: &SyncNetworkContext<T>,
-    ) -> Result<(), ()> {
-        let blob_count = blobs.iter().filter(|b| b.is_some()).count();
-        if blob_count == 0 {
-            return Ok(());
-        }
+    ) -> Result<(), LookupRequestError> {
         match cx.beacon_processor_if_enabled() {
             Some(beacon_processor) => {
                 trace!(self.log, "Sending blobs for processing"; "block" => ?block_root, "process_type" => ?process_type);
@@ -1089,54 +1398,30 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                         "Failed to send sync blobs to processor";
                         "error" => ?e
                     );
-                    Err(())
+                    Err(LookupRequestError::SendFailed(
+                        "beacon processor send failure",
+                    ))
                 } else {
                     Ok(())
                 }
             }
             None => {
                 trace!(self.log, "Dropping blobs ready for processing. Beacon processor not available"; "block_root" => %block_root);
-                Err(())
+                Err(LookupRequestError::SendFailed(
+                    "beacon processor unavailable",
+                ))
             }
         }
     }
 
+    /// Attempts to request the next unknown parent. This method handles peer scoring and dropping
+    /// the lookup in the event of failure.
     fn request_parent(&mut self, mut parent_lookup: ParentLookup<T>, cx: &SyncNetworkContext<T>) {
         let response = parent_lookup.request_parent(cx);
 
         match response {
             Err(e) => {
-                debug!(self.log, "Failed to request parent"; &parent_lookup, "error" => e.as_static());
-                match e {
-                    parent_lookup::RequestError::SendFailed(_) => {
-                        // Probably shutting down, nothing to do here. Drop the request
-                    }
-                    parent_lookup::RequestError::ChainTooLong => {
-                        self.failed_chains.insert(parent_lookup.chain_hash());
-                        // This indicates faulty peers.
-                        for &peer_id in parent_lookup.used_peers() {
-                            cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
-                        }
-                    }
-                    parent_lookup::RequestError::TooManyAttempts { cannot_process } => {
-                        // We only consider the chain failed if we were unable to process it.
-                        // We could have failed because one peer continually failed to send us
-                        // bad blocks. We still allow other peers to send us this chain. Note
-                        // that peers that do this, still get penalised.
-                        if cannot_process {
-                            self.failed_chains.insert(parent_lookup.chain_hash());
-                        }
-                        // This indicates faulty peers.
-                        for &peer_id in parent_lookup.used_peers() {
-                            cx.report_peer(peer_id, PeerAction::LowToleranceError, e.as_static())
-                        }
-                    }
-                    parent_lookup::RequestError::NoPeers => {
-                        // This happens if the peer disconnects while the block is being
-                        // processed. Drop the request without extra penalty
-                    }
-                    parent_lookup::RequestError::AlreadyDownloaded => {}
-                }
+                self.handle_parent_request_error(&mut parent_lookup, cx, e);
             }
             Ok(_) => {
                 debug!(self.log, "Requesting parent"; &parent_lookup);
@@ -1163,9 +1448,3 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         self.parent_lookups.drain(..).len()
     }
 }
-
-#[derive(Debug, Copy, Clone)]
-pub enum LookupType {
-    Current,
-    Parent,
-}
diff --git a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
index 6afeaccc7b7..b94a3be71ea 100644
--- a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
@@ -1,8 +1,7 @@
 use super::single_block_lookup::{LookupRequestError, LookupVerifyError, SingleBlockLookup};
 use super::{DownloadedBlocks, PeerShouldHave};
-use crate::sync::block_lookups::single_block_lookup::{
-    Parent, RequestState, State, UnknownParentComponents,
-};
+use crate::sync::block_lookups::common::Parent;
+use crate::sync::block_lookups::common::RequestState;
 use crate::sync::{manager::SLOT_IMPORT_TOLERANCE, network_context::SyncNetworkContext};
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::block_verification_types::RpcBlock;
@@ -55,7 +54,6 @@ pub enum RequestError {
         cannot_process: bool,
     },
     NoPeers,
-    AlreadyDownloaded,
 }
 
 impl<T: BeaconChainTypes> ParentLookup<T> {
@@ -103,55 +101,42 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
             .map_err(Into::into)
     }
 
-    pub fn check_block_peer_disconnected(&mut self, peer_id: &PeerId) -> Result<(), ()> {
+    pub fn check_peer_disconnected(&mut self, peer_id: &PeerId) -> Result<(), ()> {
         self.current_parent_request
             .block_request_state
             .state
             .check_peer_disconnected(peer_id)
-    }
-
-    pub fn check_blob_peer_disconnected(&mut self, peer_id: &PeerId) -> Result<(), ()> {
-        self.current_parent_request
-            .blob_request_state
-            .state
-            .check_peer_disconnected(peer_id)
+            .and_then(|()| {
+                self.current_parent_request
+                    .blob_request_state
+                    .state
+                    .check_peer_disconnected(peer_id)
+            })
     }
 
     pub fn add_unknown_parent_block(&mut self, block: RpcBlock<T::EthSpec>) {
         let next_parent = block.parent_root();
-
         // Cache the block.
-        let current_root = self
-            .current_parent_request
-            .block_request_state
-            .requested_block_root;
+        let current_root = self.current_parent_request.block_root();
         self.downloaded_blocks.push((current_root, block));
 
-        // Update the block request.
+        // Update the parent request.
         self.current_parent_request
-            .block_request_state
-            .requested_block_root = next_parent;
-        self.current_parent_request.block_request_state.state.state = State::AwaitingDownload;
-
-        // Update the blobs request.
-        self.current_parent_request.blob_request_state.state.state = State::AwaitingDownload;
-
-        // Reset the unknown parent components.
-        self.current_parent_request.unknown_parent_components =
-            Some(UnknownParentComponents::default());
+            .update_requested_parent_block(next_parent)
     }
 
-    pub fn processing_peer(&self) -> Result<PeerShouldHave, ()> {
+    pub fn block_processing_peer(&self) -> Result<PeerShouldHave, ()> {
         self.current_parent_request
             .block_request_state
             .state
             .processing_peer()
-            .or_else(|()| {
-                self.current_parent_request
-                    .blob_request_state
-                    .state
-                    .processing_peer()
-            })
+    }
+
+    pub fn blob_processing_peer(&self) -> Result<PeerShouldHave, ()> {
+        self.current_parent_request
+            .blob_request_state
+            .state
+            .processing_peer()
     }
 
     /// Consumes the parent request and destructures it into it's parts.
@@ -193,11 +178,7 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
             .blob_request_state
             .state
             .register_failure_processing();
-        if let Some(components) = self
-            .current_parent_request
-            .unknown_parent_components
-            .as_mut()
-        {
+        if let Some(components) = self.current_parent_request.cached_child_components.as_mut() {
             components.downloaded_block = None;
             components.downloaded_blobs = <_>::default();
         }
@@ -209,11 +190,8 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         &mut self,
         block: Option<R::ResponseType>,
         failed_chains: &mut lru_cache::LRUTimeCache<Hash256>,
-    ) -> Result<Option<(Hash256, R::VerifiedResponseType)>, ParentVerifyError> {
-        let expected_block_root = self
-            .current_parent_request
-            .block_request_state
-            .requested_block_root;
+    ) -> Result<Option<R::VerifiedResponseType>, ParentVerifyError> {
+        let expected_block_root = self.current_parent_request.block_root();
         let request_state = R::request_state_mut(&mut self.current_parent_request);
         let root_and_block = request_state.verify_response(expected_block_root, block)?;
 
@@ -221,7 +199,7 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
         // be dropped and the peer downscored.
         if let Some(parent_root) = root_and_block
             .as_ref()
-            .and_then(|(_, block)| R::get_parent_root(block))
+            .and_then(|block| R::get_parent_root(block))
         {
             if failed_chains.contains(&parent_root) {
                 request_state.register_failure_downloading();
@@ -277,7 +255,6 @@ impl From<LookupRequestError> for RequestError {
                 RequestError::TooManyAttempts { cannot_process }
             }
             E::NoPeers => RequestError::NoPeers,
-            E::AlreadyDownloaded => RequestError::AlreadyDownloaded,
             E::SendFailed(msg) => RequestError::SendFailed(msg),
         }
     }
@@ -306,7 +283,6 @@ impl RequestError {
             }
             RequestError::TooManyAttempts { cannot_process: _ } => "too_many_downloading_attempts",
             RequestError::NoPeers => "no_peers",
-            RequestError::AlreadyDownloaded => "already_downloaded",
         }
     }
 }
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index 5499c669864..3cb084d9be9 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -1,51 +1,52 @@
-use super::{PeerShouldHave, ResponseType};
-use crate::sync::block_lookups::parent_lookup::PARENT_FAIL_TOLERANCE;
-use crate::sync::block_lookups::{
-    BlockLookups, Id, LookupType, RootBlobsTuple, RootBlockTuple, SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS,
-};
-use crate::sync::manager::BlockProcessType;
+use super::PeerShouldHave;
+use crate::sync::block_lookups::common::{Lookup, RequestState};
+use crate::sync::block_lookups::Id;
+use crate::sync::manager::SingleLookupReqId;
 use crate::sync::network_context::SyncNetworkContext;
 use beacon_chain::block_verification_types::RpcBlock;
-use beacon_chain::data_availability_checker::DataAvailabilityChecker;
-use beacon_chain::{get_block_root, BeaconChainTypes};
-use lighthouse_network::rpc::methods::BlobsByRootRequest;
-use lighthouse_network::{rpc::BlocksByRootRequest, PeerId};
-use rand::seq::IteratorRandom;
-use slog::{debug, trace, Logger};
-use ssz_types::VariableList;
+use beacon_chain::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
+use beacon_chain::BeaconChainTypes;
+use lighthouse_network::{PeerAction, PeerId};
+use slog::{trace, Logger};
 use std::collections::HashSet;
 use std::marker::PhantomData;
-use std::ops::IndexMut;
 use std::sync::Arc;
-use std::time::Duration;
 use store::Hash256;
 use strum::IntoStaticStr;
 use types::blob_sidecar::{BlobIdentifier, FixedBlobSidecarList};
-use types::{BlobSidecar, EthSpec, SignedBeaconBlock};
+use types::{EthSpec, SignedBeaconBlock};
 
-pub trait Lookup {
-    const MAX_ATTEMPTS: u8;
-    fn lookup_type() -> LookupType;
-    fn max_attempts() -> u8 {
-        Self::MAX_ATTEMPTS
-    }
+#[derive(Debug, PartialEq, Eq)]
+pub enum State {
+    AwaitingDownload,
+    Downloading { peer_id: PeerShouldHave },
+    Processing { peer_id: PeerShouldHave },
 }
 
-pub struct Parent;
-pub struct Current;
-
-impl Lookup for Parent {
-    const MAX_ATTEMPTS: u8 = PARENT_FAIL_TOLERANCE;
-    fn lookup_type() -> LookupType {
-        LookupType::Parent
-    }
+#[derive(Debug, PartialEq, Eq, IntoStaticStr)]
+pub enum LookupVerifyError {
+    RootMismatch,
+    NoBlockReturned,
+    ExtraBlocksReturned,
+    UnrequestedBlobId,
+    ExtraBlobsReturned,
+    NotEnoughBlobsReturned,
+    InvalidIndex(u64),
+    /// We don't have enough information to know
+    /// whether the peer is at fault or simply missed
+    /// what was requested on gossip.
+    BenignFailure,
 }
 
-impl Lookup for Current {
-    const MAX_ATTEMPTS: u8 = SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS;
-    fn lookup_type() -> LookupType {
-        LookupType::Current
-    }
+#[derive(Debug, PartialEq, Eq, IntoStaticStr)]
+pub enum LookupRequestError {
+    /// Too many failed attempts
+    TooManyAttempts {
+        /// The failed attempts were primarily due to processing failures.
+        cannot_process: bool,
+    },
+    NoPeers,
+    SendFailed(&'static str),
 }
 
 pub struct SingleBlockLookup<L: Lookup, T: BeaconChainTypes> {
@@ -53,376 +54,297 @@ pub struct SingleBlockLookup<L: Lookup, T: BeaconChainTypes> {
     pub block_request_state: BlockRequestState<L>,
     pub blob_request_state: BlobRequestState<L, T::EthSpec>,
     pub da_checker: Arc<DataAvailabilityChecker<T>>,
-    /// Only necessary for requests triggered by an `UnknownBlockParent` or `UnknownBlockParent` because any
-    /// blocks or blobs without parents won't hit the data availability cache.
-    pub unknown_parent_components: Option<UnknownParentComponents<T::EthSpec>>,
-    /// We may want to delay the actual request trigger to give us a chance to receive all block
-    /// components over gossip.
-    pub triggered: bool,
+    /// Only necessary for requests triggered by an `UnknownBlockParent` or `UnknownBlockParent`
+    /// because any blocks or blobs without parents won't hit the data availability cache.
+    pub cached_child_components: Option<ChildComponents<T::EthSpec>>,
 }
 
-// generic across block + blob
-pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
-    type RequestType;
-    type ResponseType;
-    type ReconstructedResponseType;
-    type VerifiedResponseType;
-
-    // response verify
-    fn response_type() -> ResponseType;
-    fn get_parent_root(verified_response: &Self::VerifiedResponseType) -> Option<Hash256>;
-    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self;
-    fn add_to_parent_components(
-        verified_response: Self::VerifiedResponseType,
-        components: &mut UnknownParentComponents<T::EthSpec>,
-    );
-    fn verified_to_reconstructed(
-        verified: Self::VerifiedResponseType,
-    ) -> Self::ReconstructedResponseType;
-    fn send_for_processing(
+impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
+    pub fn new(
+        requested_block_root: Hash256,
+        unknown_parent_components: Option<ChildComponents<T::EthSpec>>,
+        peers: &[PeerShouldHave],
+        da_checker: Arc<DataAvailabilityChecker<T>>,
         id: Id,
-        bl: &mut BlockLookups<T>,
-        block_root: Hash256,
-        verified: Self::ReconstructedResponseType,
-        duration: Duration,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), ()>;
+    ) -> Self {
+        Self {
+            id,
+            block_request_state: BlockRequestState::new(requested_block_root, peers),
+            blob_request_state: BlobRequestState::new(peers),
+            da_checker,
+            cached_child_components: unknown_parent_components,
+        }
+    }
 
-    fn get_state(&self) -> &SingleLookupRequestState;
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState;
-    fn processing_peer(&self) -> Result<PeerShouldHave, ()> {
-        self.get_state().processing_peer()
+    /// Get the block root that is being requested.
+    pub fn block_root(&self) -> Hash256 {
+        self.block_request_state.requested_block_root
     }
-    fn set_component_processed(&mut self) {
-        self.get_state_mut().component_processed = true;
+
+    /// Check the block root matches the requested block root.
+    pub fn is_for_block(&self, block_root: Hash256) -> bool {
+        self.block_root() == block_root
     }
-    fn new_request(&self) -> Self::RequestType;
-    fn max_attempts() -> u8;
-    fn retry_request(
-        id: Id,
-        cx: &SyncNetworkContext<T>,
-        peer_id: PeerId,
-        request: Self::RequestType,
-    ) -> Result<(), &'static str>;
-    fn verify_response(
+
+    /// Update the requested block, this should only be used in a chain of parent lookups to request
+    /// the next parent.
+    pub fn update_requested_parent_block(&mut self, block_root: Hash256) {
+        self.block_request_state.requested_block_root = block_root;
+        self.block_request_state.state.state = State::AwaitingDownload;
+        self.blob_request_state.state.state = State::AwaitingDownload;
+        self.cached_child_components = Some(ChildComponents::default());
+    }
+
+    /// Get all unique peers across block and blob requests.
+    pub fn all_peers(&self) -> HashSet<PeerId> {
+        let mut all_peers = self.block_request_state.state.used_peers.clone();
+        all_peers.extend(self.blob_request_state.state.used_peers.clone());
+        all_peers
+    }
+
+    /// Send the necessary requests for blocks and/or blobs. This will check whether we have
+    /// downloaded the block and/or blobs already and will not send requests if so. It will also
+    /// inspect the request state or blocks and blobs to ensure we are not already processing or
+    /// downloading the block and/or blobs.
+    pub fn request_block_and_blobs(
         &mut self,
-        expected_block_root: Hash256,
-        response: Option<Self::ResponseType>,
-    ) -> Result<Option<(Hash256, Self::VerifiedResponseType)>, LookupVerifyError> {
-        let request_state = self.get_state_mut();
-        match request_state.state {
-            State::AwaitingDownload => {
-                request_state.register_failure_downloading();
-                Err(LookupVerifyError::ExtraBlocksReturned)
-            }
-            State::Downloading { peer_id } => {
-                self.verify_response_inner(expected_block_root, response, peer_id)
-            }
-            State::Processing { peer_id: _ } => match response {
-                Some(_) => {
-                    // We sent the block for processing and received an extra block.
-                    request_state.register_failure_downloading();
-                    Err(LookupVerifyError::ExtraBlocksReturned)
-                }
-                None => {
-                    // This is simply the stream termination and we are already processing the
-                    // block
-                    Ok(None)
-                }
-            },
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        let block_root = self.block_root();
+        let block_already_downloaded = self.block_already_downloaded();
+        let blobs_already_downloaded = self.blobs_already_downloaded();
+
+        if block_already_downloaded && blobs_already_downloaded {
+            trace!(cx.log, "Lookup request already completed"; "block_root"=> ?block_root);
+            return Ok(());
         }
+
+        self.request_generic::<BlockRequestState<L>>(block_already_downloaded, cx)?;
+        self.request_generic::<BlobRequestState<L, T::EthSpec>>(blobs_already_downloaded, cx)
     }
-    fn verify_response_inner(
-        &mut self,
-        expected_block_root: Hash256,
-        response: Option<Self::ResponseType>,
-        peer_id: PeerShouldHave,
-    ) -> Result<Option<(Hash256, Self::VerifiedResponseType)>, LookupVerifyError>;
 
-    fn retry_request_after_failure(
+    /// Common checks and request logic for blocks and blobs.
+    fn request_generic<R: RequestState<L, T>>(
         &mut self,
-        id: Id,
+        already_downloaded: bool,
         cx: &SyncNetworkContext<T>,
-        log: &Logger,
-    ) -> Result<(), ()> {
-        if let Err(e) = self
-            .build_request()
-            .map_err(Into::into)
-            .and_then(|(peer_id, request)| Self::retry_request(id, cx, peer_id, request))
-        {
-            //TODO(sean) pass this error up? check downloaded contents prior to retry-ing?
-            debug!(log, "Single block lookup failed";
-                    "error" => ?e,
-            );
-            return Err(());
+    ) -> Result<(), LookupRequestError> {
+        let id = self.id;
+        let request_state = R::request_state_mut(self);
+
+        let should_request = !already_downloaded
+            && matches!(request_state.get_state().state, State::AwaitingDownload);
+        if should_request {
+            let (peer_id, request) = request_state.build_request()?;
+            let id = SingleLookupReqId {
+                id,
+                req_counter: request_state.get_state().req_counter,
+            };
+            R::make_request(id, peer_id, request, cx)?;
         }
         Ok(())
     }
-    fn build_request(&mut self) -> Result<(PeerId, Self::RequestType), LookupRequestError> {
-        debug_assert!(matches!(self.get_state().state, State::AwaitingDownload));
-        self.too_many_attempts()?;
-        let peer = self.get_peer()?;
-        let request = self.new_request();
-        Ok((peer, request))
-    }
-    fn too_many_attempts(&self) -> Result<(), LookupRequestError> {
-        let max_attempts = Self::max_attempts();
-        if self.get_state().failed_attempts() >= max_attempts {
-            Err(LookupRequestError::TooManyAttempts {
-                cannot_process: self.cannot_process(),
-            })
+
+    /// Returns a `CachedChild`, which is a wrapper around a `RpcBlock` that is either:
+    ///
+    /// 1. `NotRequired`: there is no child caching required for this lookup.
+    /// 2. `DownloadIncomplete`: Child caching is required, but all components are not yet downloaded.
+    /// 3. `Ok`: The child is required and we have downloaded it.
+    /// 4. `Err`: The child is required, but has failed consistency checks.
+    pub fn get_cached_child_block(&self) -> CachedChild<T::EthSpec> {
+        if let Some(components) = self.cached_child_components.as_ref() {
+            let Some(block) = components.downloaded_block.as_ref()else {
+              return CachedChild::DownloadIncomplete
+            };
+
+            if !self.missing_blob_ids().is_empty() {
+                return CachedChild::DownloadIncomplete;
+            }
+
+            match RpcBlock::new_from_fixed(block.clone(), components.downloaded_blobs.clone()) {
+                Ok(rpc_block) => CachedChild::Ok(rpc_block),
+                Err(e) => CachedChild::Err(e),
+            }
         } else {
-            Ok(())
+            CachedChild::NotRequired
         }
     }
-    fn cannot_process(&self) -> bool {
-        let request_state = self.get_state();
-        request_state.failed_processing >= request_state.failed_downloading
-    }
-    fn get_peer(&mut self) -> Result<PeerId, LookupRequestError> {
-        let request_state = self.get_state_mut();
-        let Some(peer_id) =         request_state
-            .available_peers
-            .iter()
-            .choose(&mut rand::thread_rng())
-            .copied()
-            .map(PeerShouldHave::BlockAndBlobs).or(request_state
-            .potential_peers
-            .iter()
-            .choose(&mut rand::thread_rng())
-            .copied()
-            .map(PeerShouldHave::Neither)) else {
-           return Err(LookupRequestError::NoPeers);
-        };
-        request_state.used_peers.insert(peer_id.to_peer_id());
-        request_state.state = State::Downloading { peer_id };
-        Ok(peer_id.to_peer_id())
-    }
-    fn check_peer_disconnected(&mut self, peer: &PeerId) -> Result<(), ()> {
-        self.get_state_mut().check_peer_disconnected(peer)
-    }
-    fn remove_if_useless(&mut self, peer: &PeerId) {
-        self.get_state_mut().remove_peer_if_useless(peer)
-    }
-    fn downloading(&self) -> bool {
-        matches!(self.get_state().state, State::Downloading { .. })
-    }
-    fn register_failure_downloading(&mut self) {
-        self.get_state_mut().register_failure_downloading()
-    }
-}
-
-impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlockRequestState<L> {
-    type RequestType = BlocksByRootRequest;
-    type ResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
-    type ReconstructedResponseType = RpcBlock<T::EthSpec>;
-    type VerifiedResponseType = Arc<SignedBeaconBlock<T::EthSpec>>;
 
-    // response verify
-    fn response_type() -> ResponseType {
-        ResponseType::Block
+    /// Accepts a verified response, and adds it to the child components if required. This method
+    /// returns a `CachedChild` which provides a completed block + blob response if all components have been
+    /// received, or information about whether the child is required and if it has been downloaded.
+    pub fn add_response<R: RequestState<L, T>>(
+        &mut self,
+        verified_response: R::VerifiedResponseType,
+    ) -> CachedChild<T::EthSpec> {
+        if let Some(cached_child_components) = self.cached_child_components.as_mut() {
+            R::add_to_child_components(verified_response, cached_child_components);
+            self.get_cached_child_block()
+        } else {
+            CachedChild::NotRequired
+        }
     }
 
-    fn get_parent_root(verified_response: &Arc<SignedBeaconBlock<T::EthSpec>>) -> Option<Hash256> {
-        Some(verified_response.parent_root())
-    }
-    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
-        &mut request.block_request_state
-    }
-    fn add_to_parent_components(
-        verified_response: Arc<SignedBeaconBlock<T::EthSpec>>,
-        components: &mut UnknownParentComponents<T::EthSpec>,
-    ) {
-        components.add_unknown_parent_block(verified_response);
+    /// Add a child component to the lookup request. Merges with any existing child components.
+    pub fn add_child_components(&mut self, components: ChildComponents<T::EthSpec>) {
+        if let Some(ref mut existing_components) = self.cached_child_components {
+            let ChildComponents {
+                downloaded_block,
+                downloaded_blobs,
+            } = components;
+            if let Some(block) = downloaded_block {
+                existing_components.add_unknown_parent_block(block);
+            }
+            existing_components.add_unknown_parent_blobs(downloaded_blobs);
+        } else {
+            self.cached_child_components = Some(components);
+        }
     }
 
-    fn verified_to_reconstructed(
-        block: Arc<SignedBeaconBlock<T::EthSpec>>,
-    ) -> RpcBlock<T::EthSpec> {
-        RpcBlock::new_without_blobs(block)
+    /// Add all given peers to both block and blob request states.
+    pub fn add_peers(&mut self, peers: &[PeerShouldHave]) {
+        for peer in peers {
+            match peer {
+                PeerShouldHave::BlockAndBlobs(peer_id) => {
+                    self.block_request_state.state.add_peer(peer_id);
+                    self.blob_request_state.state.add_peer(peer_id);
+                }
+                PeerShouldHave::Neither(peer_id) => {
+                    self.block_request_state.state.add_potential_peer(peer_id);
+                    self.blob_request_state.state.add_potential_peer(peer_id);
+                }
+            }
+        }
     }
 
-    fn send_for_processing(
-        id: Id,
-        bl: &mut BlockLookups<T>,
-        block_root: Hash256,
-        constructed: RpcBlock<T::EthSpec>,
-        duration: Duration,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), ()> {
-        bl.send_block_for_processing(
-            block_root,
-            constructed,
-            duration,
-            BlockProcessType::SingleBlock { id },
-            cx,
-        )
+    /// Returns true if the block has already been downloaded.
+    pub fn both_components_downloaded(&self) -> bool {
+        self.block_request_state.state.component_downloaded
+            && self.blob_request_state.state.component_downloaded
     }
 
-    fn get_state(&self) -> &SingleLookupRequestState {
-        &self.state
-    }
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
-        &mut self.state
-    }
-    fn new_request(&self) -> BlocksByRootRequest {
-        BlocksByRootRequest::new(VariableList::from(vec![self.requested_block_root]))
-    }
-    fn max_attempts() -> u8 {
-        L::MAX_ATTEMPTS
-    }
-    fn retry_request(
-        id: Id,
-        cx: &SyncNetworkContext<T>,
-        peer_id: PeerId,
-        request: Self::RequestType,
-    ) -> Result<(), &'static str> {
-        cx.single_block_lookup_request_retry(id, peer_id, request, L::lookup_type())
+    /// Returns true if the block has already been downloaded.
+    pub fn both_components_processed(&self) -> bool {
+        self.block_request_state.state.component_processed
+            && self.blob_request_state.state.component_processed
     }
 
-    fn verify_response_inner(
+    /// Checks both the block and blob request states to see if the peer is disconnected.
+    ///
+    /// Returns true if the lookup should be dropped.
+    pub fn should_drop_lookup_on_disconnected_peer(
         &mut self,
-        expected_block_root: Hash256,
-        response: Option<Self::ResponseType>,
-        peer_id: PeerShouldHave,
-    ) -> Result<Option<RootBlockTuple<T::EthSpec>>, LookupVerifyError> {
-        match response {
-            Some(block) => {
-                // Compute the block root using this specific function so that we can get timing
-                // metrics.
-                let block_root = get_block_root(&block);
-                if block_root != expected_block_root {
-                    // return an error and drop the block
-                    // NOTE: we take this is as a download failure to prevent counting the
-                    // attempt as a chain failure, but simply a peer failure.
-                    self.state.register_failure_downloading();
-                    Err(LookupVerifyError::RootMismatch)
-                } else {
-                    // Return the block for processing.
-                    self.state.state = State::Processing { peer_id };
-                    Ok(Some((block_root, block)))
-                }
-            }
-            None => {
-                if peer_id.should_have_block() {
-                    self.state.register_failure_downloading();
-                    Err(LookupVerifyError::NoBlockReturned)
-                } else {
-                    self.state.state = State::AwaitingDownload;
-                    Err(LookupVerifyError::BenignFailure)
-                }
+        peer_id: &PeerId,
+        cx: &SyncNetworkContext<T>,
+        log: &Logger,
+    ) -> bool {
+        let block_root = self.block_root();
+        let block_peer_disconnected = self
+            .block_request_state
+            .state
+            .check_peer_disconnected(peer_id)
+            .is_err();
+        let blob_peer_disconnected = self
+            .blob_request_state
+            .state
+            .check_peer_disconnected(peer_id)
+            .is_err();
+
+        if block_peer_disconnected || blob_peer_disconnected {
+            if let Err(e) = self.request_block_and_blobs(cx) {
+                trace!(log, "Single lookup failed on peer disconnection"; "block_root" => ?block_root, "error" => ?e);
+                return true;
             }
         }
+        false
     }
-}
-
-impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlobRequestState<L, T::EthSpec> {
-    type RequestType = BlobsByRootRequest;
-    type ResponseType = Arc<BlobSidecar<T::EthSpec>>;
-    type ReconstructedResponseType = FixedBlobSidecarList<T::EthSpec>;
-    type VerifiedResponseType = FixedBlobSidecarList<T::EthSpec>;
 
-    // response verify
-    fn response_type() -> ResponseType {
-        ResponseType::Blob
+    /// Returns `true` if the block has already been downloaded.
+    pub(crate) fn block_already_downloaded(&self) -> bool {
+        if let Some(components) = self.cached_child_components.as_ref() {
+            components.downloaded_block.is_some()
+        } else {
+            self.da_checker.has_block(&self.block_root())
+        }
     }
 
-    fn get_parent_root(verified_response: &FixedBlobSidecarList<T::EthSpec>) -> Option<Hash256> {
-        verified_response
-            .into_iter()
-            .filter_map(|blob| blob.as_ref())
-            .map(|blob| blob.block_parent_root)
-            .next()
-    }
-    fn request_state_mut(request: &mut SingleBlockLookup<L, T>) -> &mut Self {
-        &mut request.blob_request_state
-    }
-    fn add_to_parent_components(
-        verified_response: FixedBlobSidecarList<T::EthSpec>,
-        components: &mut UnknownParentComponents<T::EthSpec>,
-    ) {
-        components.add_unknown_parent_blobs(verified_response);
-    }
-    fn verified_to_reconstructed(
-        blobs: FixedBlobSidecarList<T::EthSpec>,
-    ) -> FixedBlobSidecarList<T::EthSpec> {
-        blobs
+    /// Updates the `requested_ids` field of the `BlockRequestState` with the most recent picture
+    /// of which blobs still need to be requested. Returns `true` if there are no more blobs to
+    /// request.
+    pub(crate) fn blobs_already_downloaded(&mut self) -> bool {
+        self.update_blobs_request();
+        self.blob_request_state.requested_ids.is_empty()
     }
 
-    fn send_for_processing(
-        id: Id,
-        bl: &mut BlockLookups<T>,
-        block_root: Hash256,
-        verified: FixedBlobSidecarList<T::EthSpec>,
-        duration: Duration,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), ()> {
-        bl.send_blobs_for_processing(
-            block_root,
-            verified,
-            duration,
-            BlockProcessType::SingleBlob { id },
-            cx,
-        )
+    /// Updates this request with the most recent picture of which blobs still need to be requested.
+    pub fn update_blobs_request(&mut self) {
+        self.blob_request_state.requested_ids = self.missing_blob_ids()
     }
 
-    fn get_state(&self) -> &SingleLookupRequestState {
-        &self.state
-    }
-    fn get_state_mut(&mut self) -> &mut SingleLookupRequestState {
-        &mut self.state
-    }
-    fn new_request(&self) -> BlobsByRootRequest {
-        BlobsByRootRequest {
-            blob_ids: VariableList::from(self.requested_ids.clone()),
+    /// If `unknown_parent_components` is `Some`, we know block components won't hit the data
+    /// availability cache, so we don't check it. In either case we use the data availability
+    /// checker to get a picture of outstanding blob requirements for the block root.
+    pub(crate) fn missing_blob_ids(&self) -> Vec<BlobIdentifier> {
+        if let Some(components) = self.cached_child_components.as_ref() {
+            let blobs = components.downloaded_indices();
+            self.da_checker
+                .get_missing_blob_ids(
+                    self.block_root(),
+                    components.downloaded_block.as_ref(),
+                    Some(blobs),
+                )
+                .unwrap_or_default()
+        } else {
+            self.da_checker
+                .get_missing_blob_ids_checking_cache(self.block_root())
+                .unwrap_or_default()
         }
     }
-    fn max_attempts() -> u8 {
-        L::MAX_ATTEMPTS
+
+    /// Penalizes a blob peer if it should have blobs but didn't return them to us. Does not penalize
+    /// a peer who we request blobs from based on seeing a block or blobs over gossip. This may
+    /// have been a benign failure.
+    pub fn penalize_lazy_blob_peer(&mut self, cx: &SyncNetworkContext<T>) {
+        if let Ok(blob_peer) = self.blob_request_state.state.processing_peer() {
+            if let PeerShouldHave::BlockAndBlobs(blob_peer) = blob_peer {
+                cx.report_peer(
+                    blob_peer,
+                    PeerAction::MidToleranceError,
+                    "single_block_failure",
+                );
+            }
+            self.blob_request_state
+                .state
+                .remove_peer_if_useless(blob_peer.as_peer_id());
+        }
     }
-    fn retry_request(
-        id: Id,
-        cx: &SyncNetworkContext<T>,
-        peer_id: PeerId,
-        request: Self::RequestType,
-    ) -> Result<(), &'static str> {
-        cx.single_blob_lookup_request_retry(id, peer_id, request, L::lookup_type())
+
+    /// This failure occurs on download, so register a failure downloading, penalize the peer if
+    /// necessary and clear the blob cache.
+    pub fn handle_consistency_failure(&mut self, cx: &SyncNetworkContext<T>) {
+        self.penalize_lazy_blob_peer(cx);
+        if let Some(cached_child) = self.cached_child_components.as_mut() {
+            cached_child.clear_blobs();
+        }
+        self.blob_request_state.state.register_failure_downloading()
     }
 
-    fn verify_response_inner(
-        &mut self,
-        expected_block_root: Hash256,
-        blob: Option<Self::ResponseType>,
-        peer_id: PeerShouldHave,
-    ) -> Result<Option<RootBlobsTuple<T::EthSpec>>, LookupVerifyError> {
-        match blob {
-            Some(blob) => {
-                let received_id = blob.id();
-                if !self.requested_ids.contains(&received_id) {
-                    self.state.register_failure_downloading();
-                    Err(LookupVerifyError::UnrequestedBlobId)
-                } else {
-                    // State should remain downloading until we receive the stream terminator.
-                    self.requested_ids.retain(|id| *id != received_id);
-                    let blob_index = blob.index;
-
-                    if blob_index >= T::EthSpec::max_blobs_per_block() as u64 {
-                        return Err(LookupVerifyError::InvalidIndex(blob.index));
-                    }
-                    *self.blob_download_queue.index_mut(blob_index as usize) = Some(blob);
-                    Ok(None)
-                }
-            }
-            None => {
-                self.state.state = State::Processing { peer_id };
-                let blobs = std::mem::take(&mut self.blob_download_queue);
-                Ok(Some((expected_block_root, blobs)))
-            }
+    /// This failure occurs after processing, so register a failure processing, penalize the peer if
+    /// necessary and clear the blob cache.
+    pub fn handle_availability_check_failure(&mut self, cx: &SyncNetworkContext<T>) {
+        self.penalize_lazy_blob_peer(cx);
+        if let Some(cached_child) = self.cached_child_components.as_mut() {
+            cached_child.clear_blobs();
         }
+        self.blob_request_state.state.register_failure_processing()
     }
 }
 
+/// The state of the blob request component of a `SingleBlockLookup`.
 pub struct BlobRequestState<L: Lookup, T: EthSpec> {
+    /// The latest picture of which blobs still need to be requested. This includes information
+    /// from both block/blobs downloaded in the network layer and any blocks/blobs that exist in
+    /// the data availability checker.
     pub requested_ids: Vec<BlobIdentifier>,
     /// Where we store blobs until we receive the stream terminator.
     pub blob_download_queue: FixedBlobSidecarList<T>,
@@ -430,7 +352,7 @@ pub struct BlobRequestState<L: Lookup, T: EthSpec> {
     _phantom: PhantomData<L>,
 }
 
-impl<L: Lookup, T: EthSpec> BlobRequestState<L, T> {
+impl<L: Lookup, E: EthSpec> BlobRequestState<L, E> {
     pub fn new(peer_source: &[PeerShouldHave]) -> Self {
         Self {
             requested_ids: <_>::default(),
@@ -441,6 +363,7 @@ impl<L: Lookup, T: EthSpec> BlobRequestState<L, T> {
     }
 }
 
+/// The state of the block request component of a `SingleBlockLookup`.
 pub struct BlockRequestState<L: Lookup> {
     pub requested_block_root: Hash256,
     pub state: SingleLookupRequestState,
@@ -457,33 +380,34 @@ impl<L: Lookup> BlockRequestState<L> {
     }
 }
 
-impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
-    pub(crate) fn block_already_downloaded(&self) -> bool {
-        if let Some(components) = self.unknown_parent_components.as_ref() {
-            components.downloaded_block.is_some()
-        } else {
-            self.da_checker
-                .has_block(&self.block_request_state.requested_block_root)
-        }
-    }
-
-    pub(crate) fn blobs_already_downloaded(&mut self) -> bool {
-        self.update_blobs_request();
-        self.blob_request_state.requested_ids.is_empty()
-    }
+/// This is the status of cached components for a lookup if they are required. It provides information
+/// about whether we should send a responses immediately for processing, whether we require more
+/// responses, or whether all cached components have been received and the reconstructed block
+/// should be sent for processing.
+pub enum CachedChild<E: EthSpec> {
+    /// All child components have been received, this is the reconstructed block, including all.
+    /// It has been checked for consistency between blobs and block, but no consensus checks have
+    /// been performed and no kzg verification has been performed.
+    Ok(RpcBlock<E>),
+    /// All child components have not yet been received.
+    DownloadIncomplete,
+    /// Child components should not be cached, send this directly for processing.
+    NotRequired,
+    /// There was an error during consistency checks between block and blobs.
+    Err(AvailabilityCheckError),
 }
 
-/// For requests triggered by an `UnknownBlockParent` or `UnknownBlockParent`, this struct
-/// is used to cache components as they are sent to the networking layer. We can't use the
-/// data availability cache currently because any blocks or blobs without parents won't hit
+/// For requests triggered by an `UnknownBlockParent` or `UnknownBlobParent`, this struct
+/// is used to cache components as they are sent to the network service. We can't use the
+/// data availability cache currently because any blocks or blobs without parents
 /// won't pass validation and therefore won't make it into the cache.
 #[derive(Default)]
-pub struct UnknownParentComponents<E: EthSpec> {
+pub struct ChildComponents<E: EthSpec> {
     pub downloaded_block: Option<Arc<SignedBeaconBlock<E>>>,
     pub downloaded_blobs: FixedBlobSidecarList<E>,
 }
 
-impl<E: EthSpec> From<RpcBlock<E>> for UnknownParentComponents<E> {
+impl<E: EthSpec> From<RpcBlock<E>> for ChildComponents<E> {
     fn from(value: RpcBlock<E>) -> Self {
         let (block, blobs) = value.deconstruct();
         let fixed_blobs = blobs.map(|blobs| {
@@ -493,7 +417,7 @@ impl<E: EthSpec> From<RpcBlock<E>> for UnknownParentComponents<E> {
     }
 }
 
-impl<E: EthSpec> UnknownParentComponents<E> {
+impl<E: EthSpec> ChildComponents<E> {
     pub fn new(
         block: Option<Arc<SignedBeaconBlock<E>>>,
         blobs: Option<FixedBlobSidecarList<E>>,
@@ -503,9 +427,15 @@ impl<E: EthSpec> UnknownParentComponents<E> {
             downloaded_blobs: blobs.unwrap_or_default(),
         }
     }
+
+    pub fn clear_blobs(&mut self) {
+        self.downloaded_blobs = FixedBlobSidecarList::default();
+    }
+
     pub fn add_unknown_parent_block(&mut self, block: Arc<SignedBeaconBlock<E>>) {
         self.downloaded_block = Some(block);
     }
+
     pub fn add_unknown_parent_blobs(&mut self, blobs: FixedBlobSidecarList<E>) {
         for (index, blob_opt) in self.downloaded_blobs.iter_mut().enumerate() {
             if let Some(Some(downloaded_blob)) = blobs.get(index) {
@@ -513,6 +443,7 @@ impl<E: EthSpec> UnknownParentComponents<E> {
             }
         }
     }
+
     pub fn downloaded_indices(&self) -> HashSet<usize> {
         self.downloaded_blobs
             .iter()
@@ -534,254 +465,19 @@ pub struct SingleLookupRequestState {
     /// Peers from which we have requested this block.
     pub used_peers: HashSet<PeerId>,
     /// How many times have we attempted to process this block or blob.
-    failed_processing: u8,
+    pub failed_processing: u8,
     /// How many times have we attempted to download this block or blob.
-    failed_downloading: u8,
+    pub failed_downloading: u8,
+    /// Whether or not we have downloaded this block or blob.
+    pub component_downloaded: bool,
+    /// Whether or not we have processed this block or blob.
     pub component_processed: bool,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum State {
-    AwaitingDownload,
-    Downloading { peer_id: PeerShouldHave },
-    Processing { peer_id: PeerShouldHave },
-}
-
-#[derive(Debug, PartialEq, Eq, IntoStaticStr)]
-pub enum LookupVerifyError {
-    RootMismatch,
-    NoBlockReturned,
-    ExtraBlocksReturned,
-    UnrequestedBlobId,
-    ExtraBlobsReturned,
-    NotEnoughBlobsReturned,
-    InvalidIndex(u64),
-    /// We don't have enough information to know
-    /// whether the peer is at fault or simply missed
-    /// what was requested on gossip.
-    BenignFailure,
-}
-
-#[derive(Debug, PartialEq, Eq, IntoStaticStr)]
-pub enum LookupRequestError {
-    /// Too many failed attempts
-    TooManyAttempts {
-        /// The failed attempts were primarily due to processing failures.
-        cannot_process: bool,
-    },
-    NoPeers,
-    SendFailed(&'static str),
-    AlreadyDownloaded,
-}
-
-impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
-    pub fn new(
-        requested_block_root: Hash256,
-        unknown_parent_components: Option<UnknownParentComponents<T::EthSpec>>,
-        peers: &[PeerShouldHave],
-        da_checker: Arc<DataAvailabilityChecker<T>>,
-        id: Id,
-    ) -> Self {
-        Self {
-            id,
-            block_request_state: BlockRequestState::new(requested_block_root, peers),
-            blob_request_state: BlobRequestState::new(peers),
-            da_checker,
-            unknown_parent_components,
-            triggered: false,
-        }
-    }
-
-    pub fn is_for_block(&self, block_root: Hash256) -> bool {
-        self.block_request_state.requested_block_root == block_root
-    }
-
-    /// Send the necessary request for blobs and blocks and update `self.id` with the latest
-    /// request `Id`s. This will return `Err(())` if neither the block nor blob request could be made
-    /// or are no longer required.
-    pub fn request_block_and_blobs(
-        &mut self,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
-        let block_root = self.block_request_state.requested_block_root;
-        if self.block_already_downloaded() && self.blobs_already_downloaded() {
-            // drop lookup
-            trace!(cx.log, "Lookup request already completed"; "block_root"=> ?block_root);
-            return Err(LookupRequestError::AlreadyDownloaded);
-        }
-
-        let (block_peer_id, block_request) =
-            match <BlockRequestState<L> as RequestState<L, T>>::build_request(
-                &mut self.block_request_state,
-            ) {
-                Ok(opt) => opt,
-                Err(e) => {
-                    // drop lookup
-                    debug!(cx.log,
-                        "Lookup request block error, dropping lookup";
-                        "block_root"=> ?block_root,
-                        "error"=> ?e
-                    );
-                    return Err(e);
-                }
-            };
-
-        let (blob_peer_id, blob_request) = match <BlobRequestState<
-            L,
-            <T as BeaconChainTypes>::EthSpec,
-        > as RequestState<L, T>>::build_request(
-            &mut self.blob_request_state
-        ) {
-            Ok(opt) => opt,
-            Err(e) => {
-                // drop lookup
-                debug!(cx.log,
-                    "Lookup request blob error, dropping lookup";
-                    "block_root"=> ?block_root,
-                    "error"=> ?e
-                );
-                return Err(e);
-            }
-        };
-
-        cx.single_lookup_request(
-            self.id,
-            block_peer_id,
-            block_request,
-            blob_peer_id,
-            blob_request,
-            L::lookup_type(),
-        )
-        .map_err(LookupRequestError::SendFailed)?;
-        Ok(())
-    }
-
-    pub fn update_blobs_request(&mut self) {
-        self.blob_request_state.requested_ids = if let Some(components) =
-            self.unknown_parent_components.as_ref()
-        {
-            let blobs = components.downloaded_indices();
-            self.da_checker
-                .get_missing_blob_ids(
-                    self.block_request_state.requested_block_root,
-                    components.downloaded_block.as_ref(),
-                    Some(blobs),
-                )
-                .unwrap_or_default()
-        } else {
-            self.da_checker
-                .get_missing_blob_ids_checking_cache(self.block_request_state.requested_block_root)
-                .unwrap_or_default()
-        };
-    }
-
-    pub fn get_downloaded_block(&mut self) -> Option<RpcBlock<T::EthSpec>> {
-        self.unknown_parent_components
-            .as_mut()
-            .and_then(|components| {
-                let downloaded_block = components.downloaded_block.as_ref();
-                let downloaded_indices = components.downloaded_indices();
-                let missing_ids = self.da_checker.get_missing_blob_ids(
-                    self.block_request_state.requested_block_root,
-                    downloaded_block,
-                    Some(downloaded_indices),
-                );
-                let download_complete =
-                    missing_ids.map_or(true, |missing_ids| missing_ids.is_empty());
-                if download_complete {
-                    let UnknownParentComponents {
-                        downloaded_block,
-                        downloaded_blobs,
-                    } = components;
-                    downloaded_block.as_ref().and_then(|block| {
-                        //TODO(sean) figure out how to properly deal with a consistency error here,
-                        // should we downscore the peer sending blobs?
-                        let blobs = std::mem::take(downloaded_blobs);
-                        let filtered = blobs
-                            .into_iter()
-                            .filter_map(|b| b.clone())
-                            .collect::<Vec<_>>();
-                        let blobs = VariableList::from(filtered);
-                        RpcBlock::new(block.clone(), Some(blobs)).ok()
-                    })
-                } else {
-                    None
-                }
-            })
-    }
-
-    pub fn add_unknown_parent_components(
-        &mut self,
-        components: UnknownParentComponents<T::EthSpec>,
-    ) {
-        if let Some(ref mut existing_components) = self.unknown_parent_components {
-            let UnknownParentComponents {
-                downloaded_block,
-                downloaded_blobs,
-            } = components;
-            if let Some(block) = downloaded_block {
-                existing_components.add_unknown_parent_block(block);
-            }
-            existing_components.add_unknown_parent_blobs(downloaded_blobs);
-        } else {
-            self.unknown_parent_components = Some(components);
-        }
-    }
-
-    pub fn add_peers(&mut self, peers: &[PeerShouldHave]) {
-        for peer in peers {
-            match peer {
-                PeerShouldHave::BlockAndBlobs(peer_id) => {
-                    self.block_request_state.state.add_peer(peer_id);
-                    self.blob_request_state.state.add_peer(peer_id);
-                }
-                PeerShouldHave::Neither(peer_id) => {
-                    self.block_request_state.state.add_potential_peer(peer_id);
-                    self.blob_request_state.state.add_potential_peer(peer_id);
-                }
-            }
-        }
-    }
-
-    pub fn both_components_processed(&self) -> bool {
-        self.block_request_state.state.component_processed
-            && self.blob_request_state.state.component_processed
-    }
-
-    pub fn should_remove_disconnected_peer(
-        &mut self,
-        id: Id,
-        peer_id: &PeerId,
-        cx: &SyncNetworkContext<T>,
-        log: &Logger,
-    ) -> bool {
-        let useless_block_peer =
-            if <BlockRequestState<L> as RequestState<L, T>>::check_peer_disconnected(
-                &mut self.block_request_state,
-                peer_id,
-            )
-            .is_err()
-            {
-                trace!(log, "Single lookup failed on peer disconnection"; "block_root" => ?self.block_request_state.requested_block_root, "response_type" => ?ResponseType::Block);
-                self.block_request_state
-                    .retry_request_after_failure(id, cx, log)
-                    .is_err()
-            } else {
-                false
-            };
-        let useless_blob_peer = if <BlobRequestState<L, <T as BeaconChainTypes>::EthSpec> as RequestState<L, T>>::check_peer_disconnected(&mut self
-                                                                                                                                                      .blob_request_state, peer_id)
-            .is_err()
-        {
-            trace!(log, "Single lookup failed on peer disconnection"; "block_root" => ?self.block_request_state.requested_block_root, "response_type" => ?ResponseType::Blob);
-            self.blob_request_state
-                .retry_request_after_failure(id, cx, log)
-                .is_err()
-        } else {
-            false
-        };
-        useless_block_peer && useless_blob_peer
-    }
+    /// Should be incremented everytime this request is retried. The purpose of this is to
+    /// differentiate retries of the same block/blob request within a lookup. We currently penalize
+    /// peers and retry requests prior to receiving the stream terminator. This means responses
+    /// from a prior request may arrive after a new request has been sent, this counter allows
+    /// us to differentiate these two responses.
+    pub req_counter: u32,
 }
 
 impl SingleLookupRequestState {
@@ -805,7 +501,9 @@ impl SingleLookupRequestState {
             used_peers: HashSet::default(),
             failed_processing: 0,
             failed_downloading: 0,
+            component_downloaded: false,
             component_processed: false,
+            req_counter: 0,
         }
     }
 
@@ -827,11 +525,13 @@ impl SingleLookupRequestState {
         self.failed_processing + self.failed_downloading
     }
 
+    /// This method should be used for peers wrapped in `PeerShouldHave::BlockAndBlobs`.
     pub fn add_peer(&mut self, peer_id: &PeerId) {
         self.potential_peers.remove(peer_id);
         self.available_peers.insert(*peer_id);
     }
 
+    /// This method should be used for peers wrapped in `PeerShouldHave::Neither`.
     pub fn add_potential_peer(&mut self, peer_id: &PeerId) {
         if !self.available_peers.contains(peer_id) {
             self.potential_peers.insert(*peer_id);
@@ -852,6 +552,8 @@ impl SingleLookupRequestState {
         Ok(())
     }
 
+    /// Returns the id peer we downloaded from if we have downloaded a verified block, otherwise
+    /// returns an error.
     pub fn processing_peer(&self) -> Result<PeerShouldHave, ()> {
         if let State::Processing { peer_id } = &self.state {
             Ok(*peer_id)
@@ -860,6 +562,8 @@ impl SingleLookupRequestState {
         }
     }
 
+    /// Remove the given peer from the set of potential peers, so long as there is at least one
+    /// other potential peer or we have any available peers.
     pub fn remove_peer_if_useless(&mut self, peer_id: &PeerId) {
         if !self.available_peers.is_empty() || self.potential_peers.len() > 1 {
             self.potential_peers.remove(peer_id);
@@ -876,10 +580,7 @@ impl<L: Lookup, T: BeaconChainTypes> slog::Value for SingleBlockLookup<L, T> {
     ) -> slog::Result {
         serializer.emit_str("request", key)?;
         serializer.emit_arguments("lookup_type", &format_args!("{:?}", L::lookup_type()))?;
-        serializer.emit_arguments(
-            "hash",
-            &format_args!("{}", self.block_request_state.requested_block_root),
-        )?;
+        serializer.emit_arguments("hash", &format_args!("{}", self.block_root()))?;
         serializer.emit_arguments(
             "blob_ids",
             &format_args!("{:?}", self.blob_request_state.requested_ids),
@@ -924,6 +625,8 @@ impl slog::Value for SingleLookupRequestState {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::sync::block_lookups::common::LookupType;
+    use crate::sync::block_lookups::common::{Lookup, RequestState};
     use beacon_chain::builder::Witness;
     use beacon_chain::eth1_chain::CachingEth1Backend;
     use sloggers::null::NullLoggerBuilder;
diff --git a/beacon_node/network/src/sync/block_lookups/tests.rs b/beacon_node/network/src/sync/block_lookups/tests.rs
index d7c9688e502..305c0279cb1 100644
--- a/beacon_node/network/src/sync/block_lookups/tests.rs
+++ b/beacon_node/network/src/sync/block_lookups/tests.rs
@@ -1,12 +1,13 @@
 use crate::network_beacon_processor::NetworkBeaconProcessor;
 
 use crate::service::RequestId;
-use crate::sync::manager::RequestId as SyncId;
+use crate::sync::manager::{RequestId as SyncId, SingleLookupReqId};
 use crate::NetworkMessage;
 use std::sync::Arc;
 
 use super::*;
 
+use crate::sync::block_lookups::common::ResponseType;
 use beacon_chain::builder::Witness;
 use beacon_chain::eth1_chain::CachingEth1Backend;
 use beacon_chain::test_utils::{build_log, BeaconChainHarness, EphemeralHarnessType};
@@ -156,7 +157,7 @@ impl TestRig {
     }
 
     #[track_caller]
-    fn expect_block_request(&mut self, response_type: ResponseType) -> Id {
+    fn expect_block_request(&mut self, response_type: ResponseType) -> SingleLookupReqId {
         match response_type {
             ResponseType::Block => match self.network_rx.try_recv() {
                 Ok(NetworkMessage::SendRequest {
@@ -182,7 +183,7 @@ impl TestRig {
     }
 
     #[track_caller]
-    fn expect_parent_request(&mut self, response_type: ResponseType) -> Id {
+    fn expect_parent_request(&mut self, response_type: ResponseType) -> SingleLookupReqId {
         match response_type {
             ResponseType::Block => match self.network_rx.try_recv() {
                 Ok(NetworkMessage::SendRequest {
@@ -322,7 +323,7 @@ fn test_single_block_lookup_happy_path() {
     // after processing.
     bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
     bl.single_block_component_processed::<BlockRequestState<Current>>(
-        id,
+        id.id,
         BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(block_root)),
         &mut cx,
     );
@@ -471,7 +472,7 @@ fn test_single_block_lookup_becomes_parent_request() {
     // Send the stream termination. Peer should have not been penalized, and the request moved to a
     // parent request after processing.
     bl.single_block_component_processed::<BlockRequestState<Current>>(
-        id,
+        id.id,
         BlockError::ParentUnknown(block.into()).into(),
         &mut cx,
     );
@@ -766,6 +767,14 @@ fn test_parent_lookup_too_many_attempts() {
                     &cx,
                 );
                 // Send the stream termination
+
+                // Note, previously we would send the same lookup id with a stream terminator,
+                // we'd ignore it because we'd intrepret it as an unrequested response, since
+                // we already got one response for the block. I'm not sure what the intent is
+                // for having this stream terminator line in this test at all. Receiving an invalid
+                // block and a stream terminator with the same Id now results in two failed attempts,
+                // I'm unsure if this is how it should behave?
+                //
                 bl.parent_lookup_response::<BlockRequestState<Parent>>(id, peer_id, None, D, &cx);
                 rig.expect_penalty();
             }
@@ -1051,7 +1060,7 @@ fn test_single_block_lookup_ignored_response() {
     bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
     // Send an Ignored response, the request should be dropped
     bl.single_block_component_processed::<BlockRequestState<Current>>(
-        id,
+        id.id,
         BlockProcessingResult::Ignored,
         &mut cx,
     );
@@ -1216,6 +1225,7 @@ fn test_same_chain_race_condition() {
 
 mod deneb_only {
     use super::*;
+    use crate::sync::block_lookups::common::ResponseType;
     use beacon_chain::blob_verification::BlobError;
     use std::ops::IndexMut;
     use std::str::FromStr;
@@ -1229,10 +1239,10 @@ mod deneb_only {
         parent_block: Option<Arc<SignedBeaconBlock<E>>>,
         parent_blobs: Vec<Arc<BlobSidecar<E>>>,
         peer_id: PeerId,
-        block_req_id: Option<u32>,
-        parent_block_req_id: Option<u32>,
-        blob_req_id: Option<u32>,
-        parent_blob_req_id: Option<u32>,
+        block_req_id: Option<SingleLookupReqId>,
+        parent_block_req_id: Option<SingleLookupReqId>,
+        blob_req_id: Option<SingleLookupReqId>,
+        parent_blob_req_id: Option<SingleLookupReqId>,
         slot: Slot,
         block_root: Hash256,
     }
@@ -1296,7 +1306,7 @@ mod deneb_only {
                         block_root = child_root;
                         bl.search_child_block(
                             child_root,
-                            Some(UnknownParentComponents::new(Some(child_block), None)),
+                            Some(ChildComponents::new(Some(child_block), None)),
                             &[PeerShouldHave::Neither(peer_id)],
                             &mut cx,
                         );
@@ -1334,7 +1344,7 @@ mod deneb_only {
                         *blobs.index_mut(0) = Some(child_blob);
                         bl.search_child_block(
                             child_root,
-                            Some(UnknownParentComponents::new(None, Some(blobs))),
+                            Some(ChildComponents::new(None, Some(blobs))),
                             &[PeerShouldHave::Neither(peer_id)],
                             &mut cx,
                         );
@@ -1531,7 +1541,7 @@ mod deneb_only {
             // mean we do not send a new request.
             self.bl
                 .single_block_component_processed::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id"),
+                    self.block_req_id.expect("block request id").id,
                     BlockProcessingResult::Ok(AvailabilityProcessingStatus::Imported(
                         self.block_root,
                     )),
@@ -1578,7 +1588,7 @@ mod deneb_only {
         fn invalid_block_processed(mut self) -> Self {
             self.bl
                 .single_block_component_processed::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id"),
+                    self.block_req_id.expect("block request id").id,
                     BlockProcessingResult::Err(BlockError::ProposalSignatureInvalid),
                     &mut self.cx,
                 );
@@ -1589,7 +1599,7 @@ mod deneb_only {
         fn invalid_blob_processed(mut self) -> Self {
             self.bl
                 .single_block_component_processed::<BlobRequestState<Current, E>>(
-                    self.blob_req_id.expect("blob request id"),
+                    self.blob_req_id.expect("blob request id").id,
                     BlockProcessingResult::Err(BlockError::BlobValidation(
                         BlobError::ProposerSignatureInvalid,
                     )),
@@ -1602,7 +1612,7 @@ mod deneb_only {
         fn missing_components_from_block_request(mut self) -> Self {
             self.bl
                 .single_block_component_processed::<BlockRequestState<Current>>(
-                    self.block_req_id.expect("block request id"),
+                    self.block_req_id.expect("block request id").id,
                     BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
                         self.slot,
                         self.block_root,
@@ -1616,7 +1626,7 @@ mod deneb_only {
         fn missing_components_from_blob_request(mut self) -> Self {
             self.bl
                 .single_block_component_processed::<BlobRequestState<Current, E>>(
-                    self.blob_req_id.expect("blob request id"),
+                    self.blob_req_id.expect("blob request id").id,
                     BlockProcessingResult::Ok(AvailabilityProcessingStatus::MissingComponents(
                         self.slot,
                         self.block_root,
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index cedad8890f0..696a2949d5b 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -41,11 +41,10 @@ use super::range_sync::{RangeSync, RangeSyncType, EPOCHS_PER_BATCH};
 use crate::network_beacon_processor::{ChainSegmentProcessId, NetworkBeaconProcessor};
 use crate::service::NetworkMessage;
 use crate::status::ToStatusMessage;
+use crate::sync::block_lookups::common::{Current, Parent};
 use crate::sync::block_lookups::delayed_lookup;
 use crate::sync::block_lookups::delayed_lookup::DelayedLookupMessage;
-use crate::sync::block_lookups::{
-    BlobRequestState, BlockRequestState, Current, Parent, UnknownParentComponents,
-};
+use crate::sync::block_lookups::{BlobRequestState, BlockRequestState, ChildComponents};
 use crate::sync::range_sync::ByRangeRequestType;
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::block_verification_types::RpcBlock;
@@ -84,45 +83,39 @@ pub const DELAY_QUEUE_CHANNEL_SIZE: usize = 128;
 
 pub type Id = u32;
 
-#[derive(Debug, Copy, Clone)]
-pub enum ResponseType {
-    Block,
-    Blob,
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+pub struct SingleLookupReqId {
+    pub id: Id,
+    pub req_counter: Id,
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
+pub struct ParentLookupReqId {
+    pub id: Id,
+    pub req_counter: Id,
 }
 
 /// Id of rpc requests sent by sync to the network.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum RequestId {
     /// Request searching for a block given a hash.
-    SingleBlock {
-        id: Id,
-    },
-    SingleBlob {
-        id: Id,
-    },
-    /// Request searching for a block's parent. The id is the chain
-    ParentLookup {
-        id: Id,
-    },
-    ParentLookupBlob {
-        id: Id,
-    },
+    SingleBlock { id: SingleLookupReqId },
+    /// Request searching for a set of blobs given a hash.
+    SingleBlob { id: SingleLookupReqId },
+    /// Request searching for a block's parent. The id is the chain, share with the corresponding
+    /// blob id.
+    ParentLookup { id: SingleLookupReqId },
+    /// Request searching for a block's parent blobs. The id is the chain, shared with the corresponding
+    /// block id.
+    ParentLookupBlob { id: SingleLookupReqId },
     /// Request was from the backfill sync algorithm.
-    BackFillBlocks {
-        id: Id,
-    },
+    BackFillBlocks { id: Id },
     /// Backfill request that is composed by both a block range request and a blob range request.
-    BackFillBlockAndBlobs {
-        id: Id,
-    },
+    BackFillBlockAndBlobs { id: Id },
     /// The request was from a chain in the range sync algorithm.
-    RangeBlocks {
-        id: Id,
-    },
+    RangeBlocks { id: Id },
     /// Range request that is composed by both a block range request and a blob range request.
-    RangeBlockAndBlobs {
-        id: Id,
-    },
+    RangeBlockAndBlobs { id: Id },
 }
 
 #[derive(Debug)]
@@ -680,7 +673,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     block_root,
                     parent_root,
                     blob_slot,
-                    Some(UnknownParentComponents::new(None, Some(blobs))),
+                    Some(ChildComponents::new(None, Some(blobs))),
                 );
             }
             SyncMessage::UnknownBlockHashFromAttestation(peer_id, block_hash) => {
@@ -718,16 +711,9 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     }
                 }
             }
-            SyncMessage::MissingGossipBlockComponentsDelayed(block_root) => {
-                if self
-                    .block_lookups
-                    .trigger_lookup_by_root(block_root, &self.network)
-                    .is_err()
-                {
-                    // No request was made for block or blob so the lookup is dropped.
-                    self.block_lookups.remove_lookup_by_root(block_root);
-                }
-            }
+            SyncMessage::MissingGossipBlockComponentsDelayed(block_root) => self
+                .block_lookups
+                .trigger_lookup_by_root(block_root, &self.network),
             SyncMessage::Disconnect(peer_id) => {
                 self.peer_disconnect(&peer_id);
             }
@@ -796,7 +782,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         block_root: Hash256,
         parent_root: Hash256,
         slot: Slot,
-        parent_components: Option<UnknownParentComponents<T::EthSpec>>,
+        parent_components: Option<ChildComponents<T::EthSpec>>,
     ) {
         if self.should_search_for_block(slot, &peer_id) {
             self.block_lookups.search_parent(
@@ -951,7 +937,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     seen_timestamp,
                     &self.network,
                 ),
-            RequestId::SingleBlob { id: _ } => {
+            RequestId::SingleBlob { .. } => {
                 crit!(self.log, "Blob received during block request"; "peer_id" => %peer_id  );
             }
             RequestId::ParentLookup { id } => self
@@ -1023,7 +1009,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         seen_timestamp: Duration,
     ) {
         match request_id {
-            RequestId::SingleBlock { id: _ } => {
+            RequestId::SingleBlock { .. } => {
                 crit!(self.log, "Single blob received during block request"; "peer_id" => %peer_id  );
             }
             RequestId::SingleBlob { id } => self
diff --git a/beacon_node/network/src/sync/mod.rs b/beacon_node/network/src/sync/mod.rs
index 1dd33bd31c8..23e055f60af 100644
--- a/beacon_node/network/src/sync/mod.rs
+++ b/beacon_node/network/src/sync/mod.rs
@@ -9,6 +9,6 @@ mod network_context;
 mod peer_sync_info;
 mod range_sync;
 
-pub use block_lookups::UnknownParentComponents;
+pub use block_lookups::ChildComponents;
 pub use manager::{BatchProcessResult, SyncMessage};
 pub use range_sync::{BatchOperationOutcome, ChainId};
diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs
index b7c6de2fc63..adc9469d71f 100644
--- a/beacon_node/network/src/sync/network_context.rs
+++ b/beacon_node/network/src/sync/network_context.rs
@@ -7,7 +7,8 @@ use super::range_sync::{BatchId, ByRangeRequestType, ChainId};
 use crate::network_beacon_processor::NetworkBeaconProcessor;
 use crate::service::{NetworkMessage, RequestId};
 use crate::status::ToStatusMessage;
-use crate::sync::block_lookups::LookupType;
+use crate::sync::block_lookups::common::LookupType;
+use crate::sync::manager::SingleLookupReqId;
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{BeaconChain, BeaconChainTypes, EngineState};
 use fnv::FnvHashMap;
@@ -404,23 +405,9 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         }
     }
 
-    /// Sends a blocks by root request for a parent request.
-    pub fn single_lookup_request(
+    pub fn block_lookup_request(
         &self,
-        id: Id,
-        peer_id: PeerId,
-        request: BlocksByRootRequest,
-        blob_peer_id: PeerId,
-        blob_request: BlobsByRootRequest,
-        lookup_type: LookupType,
-    ) -> Result<(), &'static str> {
-        self.single_block_lookup_request_retry(id, peer_id, request, lookup_type)?;
-        self.single_blob_lookup_request_retry(id, blob_peer_id, blob_request, lookup_type)?;
-        Ok(())
-    }
-    pub fn single_block_lookup_request_retry(
-        &self,
-        id: Id,
+        id: SingleLookupReqId,
         peer_id: PeerId,
         request: BlocksByRootRequest,
         lookup_type: LookupType,
@@ -448,14 +435,18 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         Ok(())
     }
 
-    pub fn single_blob_lookup_request_retry(
+    pub fn blob_lookup_request(
         &self,
-        id: Id,
+        id: SingleLookupReqId,
         blob_peer_id: PeerId,
         blob_request: BlobsByRootRequest,
         lookup_type: LookupType,
     ) -> Result<(), &'static str> {
-        let request_id = RequestId::Sync(SyncRequestId::SingleBlob { id });
+        let sync_id = match lookup_type {
+            LookupType::Current => SyncRequestId::SingleBlock { id },
+            LookupType::Parent => SyncRequestId::ParentLookup { id },
+        };
+        let request_id = RequestId::Sync(sync_id);
 
         if !blob_request.blob_ids.is_empty() {
             trace!(
@@ -558,6 +549,12 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
             "To deal with alignment with deneb boundaries, batches need to be of just one epoch"
         );
 
+        #[cfg(test)]
+        {
+            // Keep tests only for blocks.
+            ByRangeRequestType::Blocks
+        }
+        #[cfg(not(test))]
         if let Some(data_availability_boundary) = self.chain.data_availability_boundary() {
             if epoch >= data_availability_boundary {
                 ByRangeRequestType::BlocksAndBlobs

From 4215160bc19c00163336afe0783856e7898af376 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Tue, 1 Aug 2023 18:31:01 -0400
Subject: [PATCH 07/18] smol cleanup and a bugfix

---
 .../src/network_beacon_processor/tests.rs     |  2 -
 .../network/src/sync/block_lookups/mod.rs     | 83 +++++++++----------
 2 files changed, 38 insertions(+), 47 deletions(-)

diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs
index 1bdc3a88166..2c37d177aab 100644
--- a/beacon_node/network/src/network_beacon_processor/tests.rs
+++ b/beacon_node/network/src/network_beacon_processor/tests.rs
@@ -318,7 +318,6 @@ impl TestRig {
     }
     pub fn enqueue_single_lookup_rpc_blobs(&self) {
         if let Some(blobs) = self.next_blobs.clone() {
-            dbg!(blobs.len());
             let blobs = FixedBlobSidecarList::from(
                 blobs
                     .into_iter()
@@ -1004,7 +1003,6 @@ async fn test_rpc_block_reprocessing() {
 
     rig.enqueue_single_lookup_rpc_blobs();
     if rig.next_blobs.as_ref().map(|b| b.len()).unwrap_or(0) > 0 {
-        dbg!("here");
         rig.assert_event_journal(&[RPC_BLOBS, WORKER_FREED, NOTHING_TO_DO])
             .await;
     }
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 43fb5330181..4e6e5f987f5 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -5,6 +5,7 @@ use super::BatchProcessResult;
 use super::{manager::BlockProcessType, network_context::SyncNetworkContext};
 use crate::metrics;
 use crate::network_beacon_processor::ChainSegmentProcessId;
+use crate::sync::block_lookups::common::LookupType;
 use crate::sync::block_lookups::parent_lookup::{ParentLookup, RequestError};
 use crate::sync::block_lookups::single_block_lookup::{
     CachedChild, LookupRequestError, LookupVerifyError,
@@ -16,7 +17,6 @@ use beacon_chain::validator_monitor::timestamp_now;
 use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
 pub use common::Current;
 pub use common::Lookup;
-use common::LookupType;
 pub use common::Parent;
 pub use common::RequestState;
 use fnv::FnvHashMap;
@@ -359,16 +359,10 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     /// necessary because we want to make sure all parents are processed before sending a child
     /// for processing, otherwise the block will fail validation and will be returned to the network
     /// layer with an `UnknownParent` error.
-    pub fn has_pending_parent_request(&self, target_id: Id) -> bool {
-        self.single_block_lookups.iter().any(|(id, lookup)| {
-            if *id == target_id {
-                self.parent_lookups
-                    .iter()
-                    .any(|parent_lookup| parent_lookup.chain_hash() == lookup.block_root())
-            } else {
-                false
-            }
-        })
+    pub fn has_pending_parent_request(&self, block_root: Hash256) -> bool {
+        self.parent_lookups
+            .iter()
+            .any(|parent_lookup| parent_lookup.chain_hash() == block_root)
     }
 
     /// Process a block or blob response received from a single lookup request.
@@ -383,8 +377,6 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         let id = lookup_id.id;
         let response_type = R::response_type();
 
-        let chain_hash_opt = self.has_pending_parent_request(id);
-
         let Some(lookup) = self.get_single_lookup::<R>(lookup_id) else {
             if response.is_some() {
                 warn!(
@@ -398,14 +390,8 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
 
         let expected_block_root = lookup.block_root();
 
-        match self.single_lookup_response_inner::<R>(
-            peer_id,
-            response,
-            seen_timestamp,
-            cx,
-            chain_hash_opt,
-            lookup,
-        ) {
+        match self.single_lookup_response_inner::<R>(peer_id, response, seen_timestamp, cx, lookup)
+        {
             Ok(lookup) => {
                 self.single_block_lookups.insert(id, lookup);
             }
@@ -432,7 +418,6 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         response: Option<R::ResponseType>,
         seen_timestamp: Duration,
         cx: &SyncNetworkContext<T>,
-        delay_send: bool,
         mut lookup: SingleBlockLookup<Current, T>,
     ) -> Result<SingleBlockLookup<Current, T>, LookupRequestError> {
         let response_type = R::response_type();
@@ -445,8 +430,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 self.handle_verified_response::<Current, R>(
                     seen_timestamp,
                     cx,
-                    delay_send,
-                    None,
+                    BlockProcessType::SingleBlock { id: lookup.id },
                     verified_response,
                     &mut lookup,
                 )?;
@@ -481,8 +465,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         &self,
         seen_timestamp: Duration,
         cx: &SyncNetworkContext<T>,
-        delay_send: bool,
-        chain_hash: Option<Hash256>,
+        process_type: BlockProcessType,
         verified_response: R::VerifiedResponseType,
         lookup: &mut SingleBlockLookup<L, T>,
     ) -> Result<(), LookupRequestError> {
@@ -494,23 +477,24 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             .component_downloaded = true;
 
         let cached_child = lookup.add_response::<R>(verified_response.clone());
-
         match cached_child {
             CachedChild::Ok(block) => {
-                if let Some(chain_hash) = chain_hash {
-                    if !delay_send {
-                        let process_type = match L::lookup_type() {
-                            LookupType::Parent => BlockProcessType::ParentLookup { chain_hash },
-                            LookupType::Current => BlockProcessType::SingleBlock { id },
-                        };
-                        self.send_block_for_processing(
-                            block_root,
-                            block,
-                            seen_timestamp,
-                            process_type,
-                            cx,
-                        )?
-                    }
+                // If we have an outstanding parent request for this block, delay sending the response until
+                // all parent blocks have been processed, otherwise we will fail validation with an
+                // `UnknownParent`.
+                let delay_send = match L::lookup_type() {
+                    LookupType::Parent => false,
+                    LookupType::Current => self.has_pending_parent_request(lookup.block_root()),
+                };
+
+                if !delay_send {
+                    self.send_block_for_processing(
+                        block_root,
+                        block,
+                        seen_timestamp,
+                        process_type,
+                        cx,
+                    )?
                 }
             }
             CachedChild::DownloadIncomplete => {
@@ -628,8 +612,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 self.handle_verified_response::<Parent, R>(
                     seen_timestamp,
                     cx,
-                    false,
-                    Some(parent_lookup.chain_hash()),
+                    BlockProcessType::ParentLookup {
+                        chain_hash: parent_lookup.chain_hash(),
+                    },
                     verified_response,
                     &mut parent_lookup.current_parent_request,
                 )?;
@@ -1181,7 +1166,11 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                         "chain_hash" => ?chain_hash
                     );
                     child_lookup.handle_consistency_failure(cx);
-                    if child_lookup.request_block_and_blobs(cx).is_err() {
+                    if let Err(e) = child_lookup.request_block_and_blobs(cx) {
+                        debug!(self.log,
+                            "Failed to request block and blobs, dropping lookup";
+                            "error" => ?e
+                        );
                         self.single_block_lookups.remove(&child_lookup_id);
                     }
                 }
@@ -1313,7 +1302,11 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                             "error" => ?e
                         );
                         lookup.handle_consistency_failure(cx);
-                        if lookup.request_block_and_blobs(cx).is_err() {
+                        if let Err(e) = lookup.request_block_and_blobs(cx) {
+                            debug!(self.log,
+                                "Failed to request block and blobs, droppingn lookup";
+                                "error" => ?e
+                            );
                             self.single_block_lookups.remove(&id);
                         }
                     }

From c71e011a1cc4482c2d31b0d37481e5b4b6dc2ac2 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Tue, 1 Aug 2023 19:08:41 -0400
Subject: [PATCH 08/18] remove ParentLookupReqId

---
 beacon_node/network/src/sync/manager.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index 696a2949d5b..03d7fdc2a93 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -89,12 +89,6 @@ pub struct SingleLookupReqId {
     pub req_counter: Id,
 }
 
-#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
-pub struct ParentLookupReqId {
-    pub id: Id,
-    pub req_counter: Id,
-}
-
 /// Id of rpc requests sent by sync to the network.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum RequestId {

From 122def5ef4bf7c7a9d0c7b4d934388317acb1610 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@GMAIL.com>
Date: Thu, 3 Aug 2023 09:43:50 -0400
Subject: [PATCH 09/18] Update beacon_node/network/src/sync/manager.rs

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>
---
 beacon_node/network/src/sync/manager.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index 03d7fdc2a93..9f6b14d4d57 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -944,7 +944,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     &self.network,
                 ),
             RequestId::ParentLookupBlob { id: _ } => {
-                crit!(self.log, "Blob received during parent block request"; "peer_id" => %peer_id  );
+                crit!(self.log, "Block received during parent blob request"; "peer_id" => %peer_id  );
             }
             RequestId::BackFillBlocks { id } => {
                 let is_stream_terminator = block.is_none();

From 5736891b60405d44c7493d752d892d70432fd766 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@GMAIL.com>
Date: Thu, 3 Aug 2023 09:44:07 -0400
Subject: [PATCH 10/18] Update beacon_node/network/src/sync/manager.rs

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>
---
 beacon_node/network/src/sync/manager.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index 9f6b14d4d57..d61e34c21ca 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -932,7 +932,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     &self.network,
                 ),
             RequestId::SingleBlob { .. } => {
-                crit!(self.log, "Blob received during block request"; "peer_id" => %peer_id  );
+                crit!(self.log, "Block received during blob request"; "peer_id" => %peer_id  );
             }
             RequestId::ParentLookup { id } => self
                 .block_lookups

From 064bf64dff86b3229316aeed0431c3f4251571a5 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Thu, 3 Aug 2023 09:50:52 -0400
Subject: [PATCH 11/18] update unreachables to crits

---
 beacon_node/network/src/router.rs | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs
index 927229e7b7e..3b7431822e7 100644
--- a/beacon_node/network/src/router.rs
+++ b/beacon_node/network/src/router.rs
@@ -21,7 +21,7 @@ use lighthouse_network::{
     MessageId, NetworkGlobals, PeerId, PeerRequestId, PubsubMessage, Request, Response,
 };
 use logging::TimeLatch;
-use slog::{debug, o, trace};
+use slog::{crit, debug, o, trace};
 use slog::{error, warn};
 use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -486,14 +486,16 @@ impl<T: BeaconChainTypes> Router<T> {
                 | SyncId::SingleBlob { .. }
                 | SyncId::ParentLookup { .. }
                 | SyncId::ParentLookupBlob { .. } => {
-                    unreachable!("Block lookups do not request BBRange requests")
+                    crit!(self.log, "Block lookups do not request BBRange requests"; "peer_id" => %peer_id);
                 }
                 id @ (SyncId::BackFillBlocks { .. }
                 | SyncId::RangeBlocks { .. }
                 | SyncId::BackFillBlockAndBlobs { .. }
                 | SyncId::RangeBlockAndBlobs { .. }) => id,
             },
-            RequestId::Router => unreachable!("All BBRange requests belong to sync"),
+            RequestId::Router => {
+                crit!(self.log, "All BBRange requests belong to sync"; "peer_id" => %peer_id)
+            }
         };
 
         trace!(
@@ -551,13 +553,15 @@ impl<T: BeaconChainTypes> Router<T> {
                 | SyncId::RangeBlocks { .. }
                 | SyncId::RangeBlockAndBlobs { .. }
                 | SyncId::BackFillBlockAndBlobs { .. } => {
-                    unreachable!("Batch syncing do not request BBRoot requests")
+                    crit!(self.log, "Batch syncing do not request BBRoot requests"; "peer_id" => %peer_id)
                 }
                 SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. } => {
-                    unreachable!("Blob response to block by roots request")
+                    crit!(self.log, "Blob response to block by roots request"; "peer_id" => %peer_id)
                 }
             },
-            RequestId::Router => unreachable!("All BBRoot requests belong to sync"),
+            RequestId::Router => {
+                crit!(self.log, "All BBRoot requests belong to sync"; "peer_id" => %peer_id)
+            }
         };
 
         trace!(
@@ -584,16 +588,18 @@ impl<T: BeaconChainTypes> Router<T> {
             RequestId::Sync(sync_id) => match sync_id {
                 id @ (SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. }) => id,
                 SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. } => {
-                    unreachable!("Block response to blobs by roots request")
+                    crit!(self.log, "Block response to blobs by roots request"; "peer_id" => %peer_id)
                 }
                 SyncId::BackFillBlocks { .. }
                 | SyncId::RangeBlocks { .. }
                 | SyncId::RangeBlockAndBlobs { .. }
                 | SyncId::BackFillBlockAndBlobs { .. } => {
-                    unreachable!("Batch syncing does not request BBRoot requests")
+                    crit!(self.log, "Batch syncing does not request BBRoot requests"; "peer_id" => %peer_id)
                 }
             },
-            RequestId::Router => unreachable!("All BlobsByRoot requests belong to sync"),
+            RequestId::Router => {
+                crit!(self.log, "All BlobsByRoot requests belong to sync"; "peer_id" => %peer_id)
+            }
         };
 
         trace!(

From 460f7121cad09bb85371fe0dfc9672050a83a378 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Thu, 3 Aug 2023 10:05:22 -0400
Subject: [PATCH 12/18] Revert "update unreachables to crits"

This reverts commit 064bf64dff86b3229316aeed0431c3f4251571a5.
---
 beacon_node/network/src/router.rs | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs
index 3b7431822e7..927229e7b7e 100644
--- a/beacon_node/network/src/router.rs
+++ b/beacon_node/network/src/router.rs
@@ -21,7 +21,7 @@ use lighthouse_network::{
     MessageId, NetworkGlobals, PeerId, PeerRequestId, PubsubMessage, Request, Response,
 };
 use logging::TimeLatch;
-use slog::{crit, debug, o, trace};
+use slog::{debug, o, trace};
 use slog::{error, warn};
 use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -486,16 +486,14 @@ impl<T: BeaconChainTypes> Router<T> {
                 | SyncId::SingleBlob { .. }
                 | SyncId::ParentLookup { .. }
                 | SyncId::ParentLookupBlob { .. } => {
-                    crit!(self.log, "Block lookups do not request BBRange requests"; "peer_id" => %peer_id);
+                    unreachable!("Block lookups do not request BBRange requests")
                 }
                 id @ (SyncId::BackFillBlocks { .. }
                 | SyncId::RangeBlocks { .. }
                 | SyncId::BackFillBlockAndBlobs { .. }
                 | SyncId::RangeBlockAndBlobs { .. }) => id,
             },
-            RequestId::Router => {
-                crit!(self.log, "All BBRange requests belong to sync"; "peer_id" => %peer_id)
-            }
+            RequestId::Router => unreachable!("All BBRange requests belong to sync"),
         };
 
         trace!(
@@ -553,15 +551,13 @@ impl<T: BeaconChainTypes> Router<T> {
                 | SyncId::RangeBlocks { .. }
                 | SyncId::RangeBlockAndBlobs { .. }
                 | SyncId::BackFillBlockAndBlobs { .. } => {
-                    crit!(self.log, "Batch syncing do not request BBRoot requests"; "peer_id" => %peer_id)
+                    unreachable!("Batch syncing do not request BBRoot requests")
                 }
                 SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. } => {
-                    crit!(self.log, "Blob response to block by roots request"; "peer_id" => %peer_id)
+                    unreachable!("Blob response to block by roots request")
                 }
             },
-            RequestId::Router => {
-                crit!(self.log, "All BBRoot requests belong to sync"; "peer_id" => %peer_id)
-            }
+            RequestId::Router => unreachable!("All BBRoot requests belong to sync"),
         };
 
         trace!(
@@ -588,18 +584,16 @@ impl<T: BeaconChainTypes> Router<T> {
             RequestId::Sync(sync_id) => match sync_id {
                 id @ (SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. }) => id,
                 SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. } => {
-                    crit!(self.log, "Block response to blobs by roots request"; "peer_id" => %peer_id)
+                    unreachable!("Block response to blobs by roots request")
                 }
                 SyncId::BackFillBlocks { .. }
                 | SyncId::RangeBlocks { .. }
                 | SyncId::RangeBlockAndBlobs { .. }
                 | SyncId::BackFillBlockAndBlobs { .. } => {
-                    crit!(self.log, "Batch syncing does not request BBRoot requests"; "peer_id" => %peer_id)
+                    unreachable!("Batch syncing does not request BBRoot requests")
                 }
             },
-            RequestId::Router => {
-                crit!(self.log, "All BlobsByRoot requests belong to sync"; "peer_id" => %peer_id)
-            }
+            RequestId::Router => unreachable!("All BlobsByRoot requests belong to sync"),
         };
 
         trace!(

From 74373a9bd7a460911fcc3e7e8b23018c2506f821 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Thu, 3 Aug 2023 10:32:03 -0400
Subject: [PATCH 13/18] update make request/build request to make more sense

---
 .../network/src/sync/block_lookups/common.rs  | 39 ++++++++++++++++---
 .../network/src/sync/block_lookups/mod.rs     |  2 +-
 .../sync/block_lookups/single_block_lookup.rs | 28 ++-----------
 3 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/beacon_node/network/src/sync/block_lookups/common.rs b/beacon_node/network/src/sync/block_lookups/common.rs
index b4711e26be5..a5d822776d6 100644
--- a/beacon_node/network/src/sync/block_lookups/common.rs
+++ b/beacon_node/network/src/sync/block_lookups/common.rs
@@ -89,15 +89,43 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
     /* Request building methods */
 
     /// Construct a new request.
-    fn build_request(&mut self) -> Result<(PeerId, Self::RequestType), LookupRequestError> {
-        debug_assert!(matches!(self.get_state().state, State::AwaitingDownload));
+    fn build_request(
+        &mut self,
+    ) -> Result<(PeerShouldHave, Self::RequestType), LookupRequestError> {
+        // Verify and construct request.
         self.too_many_attempts()?;
         let peer = self.get_peer()?;
         let request = self.new_request();
-        self.get_state_mut().req_counter += 1;
         Ok((peer, request))
     }
 
+    /// Construct a new request and send it.
+    fn build_request_and_send(
+        &mut self,
+        id: Id,
+        already_downloaded: bool,
+        cx: &SyncNetworkContext<T>,
+    ) -> Result<(), LookupRequestError> {
+        // Check if request is necessary.
+        if already_downloaded || !matches!(self.get_state().state, State::AwaitingDownload) {
+            return Ok(());
+        }
+
+        // Construct request.
+        let (peer_id, request) = self.build_request()?;
+
+        // Update request state.
+        self.get_state_mut().state = State::Downloading { peer_id };
+        self.get_state_mut().req_counter += 1;
+
+        // Make request
+        let id = SingleLookupReqId {
+            id,
+            req_counter: self.get_state().req_counter,
+        };
+        Self::make_request(id, peer_id.to_peer_id(), request, cx)
+    }
+
     /// Verify the current request has not exceeded the maximum number of attempts.
     fn too_many_attempts(&self) -> Result<(), LookupRequestError> {
         let max_attempts = L::max_attempts();
@@ -114,7 +142,7 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
 
     /// Get the next peer to request. Draws from the set of peers we think should have both the
     /// block and blob first. If that fails, we draw from the set of peers that may have either.
-    fn get_peer(&mut self) -> Result<PeerId, LookupRequestError> {
+    fn get_peer(&mut self) -> Result<PeerShouldHave, LookupRequestError> {
         let request_state = self.get_state_mut();
         let available_peer_opt = request_state
             .available_peers
@@ -132,8 +160,7 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
             return Err(LookupRequestError::NoPeers);
         };
         request_state.used_peers.insert(peer_id.to_peer_id());
-        request_state.state = State::Downloading { peer_id };
-        Ok(peer_id.to_peer_id())
+        Ok(peer_id)
     }
 
     /// Initialize `Self::RequestType`.
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 4e6e5f987f5..4374c4ac5b3 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -885,7 +885,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     /// blobs peer because they did not provide all blobs on the initial request.
     fn handle_missing_components<R: RequestState<Current, T>>(
         &self,
-        cx: &mut SyncNetworkContext<T>,
+        cx: &SyncNetworkContext<T>,
         lookup: &mut SingleBlockLookup<Current, T>,
     ) -> Result<(), LookupRequestError> {
         let request_state = R::request_state_mut(lookup);
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index 3cb084d9be9..eeea6b1d989 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -118,31 +118,11 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
             trace!(cx.log, "Lookup request already completed"; "block_root"=> ?block_root);
             return Ok(());
         }
-
-        self.request_generic::<BlockRequestState<L>>(block_already_downloaded, cx)?;
-        self.request_generic::<BlobRequestState<L, T::EthSpec>>(blobs_already_downloaded, cx)
-    }
-
-    /// Common checks and request logic for blocks and blobs.
-    fn request_generic<R: RequestState<L, T>>(
-        &mut self,
-        already_downloaded: bool,
-        cx: &SyncNetworkContext<T>,
-    ) -> Result<(), LookupRequestError> {
         let id = self.id;
-        let request_state = R::request_state_mut(self);
-
-        let should_request = !already_downloaded
-            && matches!(request_state.get_state().state, State::AwaitingDownload);
-        if should_request {
-            let (peer_id, request) = request_state.build_request()?;
-            let id = SingleLookupReqId {
-                id,
-                req_counter: request_state.get_state().req_counter,
-            };
-            R::make_request(id, peer_id, request, cx)?;
-        }
-        Ok(())
+        self.block_request_state
+            .build_request_and_send(id, block_already_downloaded, cx)?;
+        self.blob_request_state
+            .build_request_and_send(id, blobs_already_downloaded, cx)
     }
 
     /// Returns a `CachedChild`, which is a wrapper around a `RpcBlock` that is either:

From af5e0d455c3699de979729bb6746254b8e06894b Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Thu, 3 Aug 2023 11:04:32 -0400
Subject: [PATCH 14/18] pr feedback

---
 beacon_node/network/src/router.rs             | 32 +++++++---
 .../network/src/sync/block_lookups/common.rs  | 18 +++---
 .../network/src/sync/block_lookups/mod.rs     | 10 ++--
 .../sync/block_lookups/single_block_lookup.rs | 21 ++++---
 .../network/src/sync/block_lookups/tests.rs   | 58 +++++++++----------
 beacon_node/network/src/sync/manager.rs       |  6 +-
 beacon_node/network/src/sync/mod.rs           |  2 +-
 .../network/src/sync/network_context.rs       |  4 +-
 8 files changed, 83 insertions(+), 68 deletions(-)

diff --git a/beacon_node/network/src/router.rs b/beacon_node/network/src/router.rs
index 927229e7b7e..86181c347d3 100644
--- a/beacon_node/network/src/router.rs
+++ b/beacon_node/network/src/router.rs
@@ -21,7 +21,7 @@ use lighthouse_network::{
     MessageId, NetworkGlobals, PeerId, PeerRequestId, PubsubMessage, Request, Response,
 };
 use logging::TimeLatch;
-use slog::{debug, o, trace};
+use slog::{crit, debug, o, trace};
 use slog::{error, warn};
 use std::sync::Arc;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
@@ -486,14 +486,18 @@ impl<T: BeaconChainTypes> Router<T> {
                 | SyncId::SingleBlob { .. }
                 | SyncId::ParentLookup { .. }
                 | SyncId::ParentLookupBlob { .. } => {
-                    unreachable!("Block lookups do not request BBRange requests")
+                    crit!(self.log, "Block lookups do not request BBRange requests"; "peer_id" => %peer_id);
+                    return;
                 }
                 id @ (SyncId::BackFillBlocks { .. }
                 | SyncId::RangeBlocks { .. }
                 | SyncId::BackFillBlockAndBlobs { .. }
                 | SyncId::RangeBlockAndBlobs { .. }) => id,
             },
-            RequestId::Router => unreachable!("All BBRange requests belong to sync"),
+            RequestId::Router => {
+                crit!(self.log, "All BBRange requests belong to sync"; "peer_id" => %peer_id);
+                return;
+            }
         };
 
         trace!(
@@ -551,13 +555,18 @@ impl<T: BeaconChainTypes> Router<T> {
                 | SyncId::RangeBlocks { .. }
                 | SyncId::RangeBlockAndBlobs { .. }
                 | SyncId::BackFillBlockAndBlobs { .. } => {
-                    unreachable!("Batch syncing do not request BBRoot requests")
+                    crit!(self.log, "Batch syncing do not request BBRoot requests"; "peer_id" => %peer_id);
+                    return;
                 }
                 SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. } => {
-                    unreachable!("Blob response to block by roots request")
+                    crit!(self.log, "Blob response to block by roots request"; "peer_id" => %peer_id);
+                    return;
                 }
             },
-            RequestId::Router => unreachable!("All BBRoot requests belong to sync"),
+            RequestId::Router => {
+                crit!(self.log, "All BBRoot requests belong to sync"; "peer_id" => %peer_id);
+                return;
+            }
         };
 
         trace!(
@@ -584,16 +593,21 @@ impl<T: BeaconChainTypes> Router<T> {
             RequestId::Sync(sync_id) => match sync_id {
                 id @ (SyncId::SingleBlob { .. } | SyncId::ParentLookupBlob { .. }) => id,
                 SyncId::SingleBlock { .. } | SyncId::ParentLookup { .. } => {
-                    unreachable!("Block response to blobs by roots request")
+                    crit!(self.log, "Block response to blobs by roots request"; "peer_id" => %peer_id);
+                    return;
                 }
                 SyncId::BackFillBlocks { .. }
                 | SyncId::RangeBlocks { .. }
                 | SyncId::RangeBlockAndBlobs { .. }
                 | SyncId::BackFillBlockAndBlobs { .. } => {
-                    unreachable!("Batch syncing does not request BBRoot requests")
+                    crit!(self.log, "Batch syncing does not request BBRoot requests"; "peer_id" => %peer_id);
+                    return;
                 }
             },
-            RequestId::Router => unreachable!("All BlobsByRoot requests belong to sync"),
+            RequestId::Router => {
+                crit!(self.log, "All BlobsByRoot requests belong to sync"; "peer_id" => %peer_id);
+                return;
+            }
         };
 
         trace!(
diff --git a/beacon_node/network/src/sync/block_lookups/common.rs b/beacon_node/network/src/sync/block_lookups/common.rs
index a5d822776d6..aa12acc12c7 100644
--- a/beacon_node/network/src/sync/block_lookups/common.rs
+++ b/beacon_node/network/src/sync/block_lookups/common.rs
@@ -8,7 +8,7 @@ use crate::sync::block_lookups::{
 };
 use crate::sync::manager::{BlockProcessType, Id, SingleLookupReqId};
 use crate::sync::network_context::SyncNetworkContext;
-use crate::sync::ChildComponents;
+use crate::sync::CachedChildComponents;
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::{get_block_root, BeaconChainTypes};
 use lighthouse_network::rpc::methods::BlobsByRootRequest;
@@ -89,9 +89,7 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
     /* Request building methods */
 
     /// Construct a new request.
-    fn build_request(
-        &mut self,
-    ) -> Result<(PeerShouldHave, Self::RequestType), LookupRequestError> {
+    fn build_request(&mut self) -> Result<(PeerShouldHave, Self::RequestType), LookupRequestError> {
         // Verify and construct request.
         self.too_many_attempts()?;
         let peer = self.get_peer()?;
@@ -222,7 +220,7 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
     /// triggered by `UnknownParent` errors.
     fn add_to_child_components(
         verified_response: Self::VerifiedResponseType,
-        components: &mut ChildComponents<T::EthSpec>,
+        components: &mut CachedChildComponents<T::EthSpec>,
     );
 
     /// Convert a verified response to the type we send to the beacon processor.
@@ -231,7 +229,7 @@ pub trait RequestState<L: Lookup, T: BeaconChainTypes> {
     ) -> Self::ReconstructedResponseType;
 
     /// Send the response to the beacon processor.
-    fn send_for_processing(
+    fn send_reconstructed_for_processing(
         id: Id,
         bl: &BlockLookups<T>,
         block_root: Hash256,
@@ -326,7 +324,7 @@ impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlockRequestState<L>
 
     fn add_to_child_components(
         verified_response: Arc<SignedBeaconBlock<T::EthSpec>>,
-        components: &mut ChildComponents<T::EthSpec>,
+        components: &mut CachedChildComponents<T::EthSpec>,
     ) {
         components.add_unknown_parent_block(verified_response);
     }
@@ -337,7 +335,7 @@ impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlockRequestState<L>
         RpcBlock::new_without_blobs(block)
     }
 
-    fn send_for_processing(
+    fn send_reconstructed_for_processing(
         id: Id,
         bl: &BlockLookups<T>,
         block_root: Hash256,
@@ -432,7 +430,7 @@ impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlobRequestState<L,
 
     fn add_to_child_components(
         verified_response: FixedBlobSidecarList<T::EthSpec>,
-        components: &mut ChildComponents<T::EthSpec>,
+        components: &mut CachedChildComponents<T::EthSpec>,
     ) {
         components.add_unknown_parent_blobs(verified_response);
     }
@@ -443,7 +441,7 @@ impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlobRequestState<L,
         blobs
     }
 
-    fn send_for_processing(
+    fn send_reconstructed_for_processing(
         id: Id,
         bl: &BlockLookups<T>,
         block_root: Hash256,
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 4374c4ac5b3..0c1bc4e15bd 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -23,7 +23,7 @@ use fnv::FnvHashMap;
 use lighthouse_network::rpc::RPCError;
 use lighthouse_network::{PeerAction, PeerId};
 use lru_cache::LRUTimeCache;
-pub use single_block_lookup::ChildComponents;
+pub use single_block_lookup::CachedChildComponents;
 pub use single_block_lookup::{BlobRequestState, BlockRequestState};
 use slog::{debug, error, trace, warn, Logger};
 use smallvec::SmallVec;
@@ -155,7 +155,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn search_child_block(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<ChildComponents<T::EthSpec>>,
+        parent_components: Option<CachedChildComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) {
@@ -175,7 +175,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn search_child_delayed(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<ChildComponents<T::EthSpec>>,
+        parent_components: Option<CachedChildComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) {
@@ -235,7 +235,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn new_current_lookup(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<ChildComponents<T::EthSpec>>,
+        parent_components: Option<CachedChildComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) -> Option<SingleBlockLookup<Current, T>> {
@@ -511,7 +511,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 }
                 lookup.request_block_and_blobs(cx)?;
             }
-            CachedChild::NotRequired => R::send_for_processing(
+            CachedChild::NotRequired => R::send_reconstructed_for_processing(
                 id,
                 self,
                 block_root,
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index eeea6b1d989..fef676c8719 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -1,7 +1,6 @@
 use super::PeerShouldHave;
 use crate::sync::block_lookups::common::{Lookup, RequestState};
 use crate::sync::block_lookups::Id;
-use crate::sync::manager::SingleLookupReqId;
 use crate::sync::network_context::SyncNetworkContext;
 use beacon_chain::block_verification_types::RpcBlock;
 use beacon_chain::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
@@ -56,13 +55,13 @@ pub struct SingleBlockLookup<L: Lookup, T: BeaconChainTypes> {
     pub da_checker: Arc<DataAvailabilityChecker<T>>,
     /// Only necessary for requests triggered by an `UnknownBlockParent` or `UnknownBlockParent`
     /// because any blocks or blobs without parents won't hit the data availability cache.
-    pub cached_child_components: Option<ChildComponents<T::EthSpec>>,
+    pub cached_child_components: Option<CachedChildComponents<T::EthSpec>>,
 }
 
 impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
     pub fn new(
         requested_block_root: Hash256,
-        unknown_parent_components: Option<ChildComponents<T::EthSpec>>,
+        unknown_parent_components: Option<CachedChildComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
         da_checker: Arc<DataAvailabilityChecker<T>>,
         id: Id,
@@ -92,7 +91,7 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
         self.block_request_state.requested_block_root = block_root;
         self.block_request_state.state.state = State::AwaitingDownload;
         self.blob_request_state.state.state = State::AwaitingDownload;
-        self.cached_child_components = Some(ChildComponents::default());
+        self.cached_child_components = Some(CachedChildComponents::default());
     }
 
     /// Get all unique peers across block and blob requests.
@@ -166,9 +165,9 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
     }
 
     /// Add a child component to the lookup request. Merges with any existing child components.
-    pub fn add_child_components(&mut self, components: ChildComponents<T::EthSpec>) {
+    pub fn add_child_components(&mut self, components: CachedChildComponents<T::EthSpec>) {
         if let Some(ref mut existing_components) = self.cached_child_components {
-            let ChildComponents {
+            let CachedChildComponents {
                 downloaded_block,
                 downloaded_blobs,
             } = components;
@@ -382,12 +381,12 @@ pub enum CachedChild<E: EthSpec> {
 /// data availability cache currently because any blocks or blobs without parents
 /// won't pass validation and therefore won't make it into the cache.
 #[derive(Default)]
-pub struct ChildComponents<E: EthSpec> {
+pub struct CachedChildComponents<E: EthSpec> {
     pub downloaded_block: Option<Arc<SignedBeaconBlock<E>>>,
     pub downloaded_blobs: FixedBlobSidecarList<E>,
 }
 
-impl<E: EthSpec> From<RpcBlock<E>> for ChildComponents<E> {
+impl<E: EthSpec> From<RpcBlock<E>> for CachedChildComponents<E> {
     fn from(value: RpcBlock<E>) -> Self {
         let (block, blobs) = value.deconstruct();
         let fixed_blobs = blobs.map(|blobs| {
@@ -397,7 +396,7 @@ impl<E: EthSpec> From<RpcBlock<E>> for ChildComponents<E> {
     }
 }
 
-impl<E: EthSpec> ChildComponents<E> {
+impl<E: EthSpec> CachedChildComponents<E> {
     pub fn new(
         block: Option<Arc<SignedBeaconBlock<E>>>,
         blobs: Option<FixedBlobSidecarList<E>>,
@@ -678,6 +677,8 @@ mod tests {
             &mut sl.block_request_state,
         )
         .unwrap();
+        sl.block_request_state.state.state = State::Downloading { peer_id };
+
         <BlockRequestState<TestLookup1> as RequestState<TestLookup1, T>>::verify_response(
             &mut sl.block_request_state,
             block.canonical_root(),
@@ -726,6 +727,8 @@ mod tests {
             &mut sl.block_request_state,
         )
         .unwrap();
+        sl.block_request_state.state.state = State::Downloading { peer_id };
+
         <BlockRequestState<TestLookup2> as RequestState<TestLookup2, T>>::verify_response(
             &mut sl.block_request_state,
             block.canonical_root(),
diff --git a/beacon_node/network/src/sync/block_lookups/tests.rs b/beacon_node/network/src/sync/block_lookups/tests.rs
index 305c0279cb1..5799a3762e6 100644
--- a/beacon_node/network/src/sync/block_lookups/tests.rs
+++ b/beacon_node/network/src/sync/block_lookups/tests.rs
@@ -157,7 +157,7 @@ impl TestRig {
     }
 
     #[track_caller]
-    fn expect_block_request(&mut self, response_type: ResponseType) -> SingleLookupReqId {
+    fn expect_lookup_request(&mut self, response_type: ResponseType) -> SingleLookupReqId {
         match response_type {
             ResponseType::Block => match self.network_rx.try_recv() {
                 Ok(NetworkMessage::SendRequest {
@@ -173,7 +173,7 @@ impl TestRig {
                 Ok(NetworkMessage::SendRequest {
                     peer_id: _,
                     request: Request::BlobsByRoot(_request),
-                    request_id: RequestId::Sync(SyncId::SingleBlock { id }),
+                    request_id: RequestId::Sync(SyncId::SingleBlob { id }),
                 }) => id,
                 other => {
                     panic!("Expected blob request, found {:?}", other);
@@ -197,7 +197,7 @@ impl TestRig {
                 Ok(NetworkMessage::SendRequest {
                     peer_id: _,
                     request: Request::BlobsByRoot(_request),
-                    request_id: RequestId::Sync(SyncId::ParentLookup { id }),
+                    request_id: RequestId::Sync(SyncId::ParentLookupBlob { id }),
                 }) => id,
                 other => panic!("Expected parent blobs request, found {:?}", other),
             },
@@ -297,11 +297,11 @@ fn test_single_block_lookup_happy_path() {
     let block_root = block.canonical_root();
     // Trigger the request
     bl.search_block(block_root, PeerShouldHave::BlockAndBlobs(peer_id), &mut cx);
-    let id = rig.expect_block_request(response_type);
+    let id = rig.expect_lookup_request(response_type);
     // If we're in deneb, a blob request should have been triggered as well,
     // we don't require a response because we're generateing 0-blob blocks in this test.
     if matches!(fork_name, ForkName::Deneb) {
-        let _ = rig.expect_block_request(ResponseType::Blob);
+        let _ = rig.expect_lookup_request(ResponseType::Blob);
     }
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
@@ -345,18 +345,18 @@ fn test_single_block_lookup_empty_response() {
 
     // Trigger the request
     bl.search_block(block_hash, PeerShouldHave::BlockAndBlobs(peer_id), &mut cx);
-    let id = rig.expect_block_request(response_type);
+    let id = rig.expect_lookup_request(response_type);
     // If we're in deneb, a blob request should have been triggered as well,
     // we don't require a response because we're generateing 0-blob blocks in this test.
     if matches!(fork_name, ForkName::Deneb) {
-        let _ = rig.expect_block_request(ResponseType::Blob);
+        let _ = rig.expect_lookup_request(ResponseType::Blob);
     }
 
     // The peer does not have the block. It should be penalized.
     bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
     rig.expect_penalty();
 
-    rig.expect_block_request(response_type); // it should be retried
+    rig.expect_lookup_request(response_type); // it should be retried
 }
 
 #[test]
@@ -373,11 +373,11 @@ fn test_single_block_lookup_wrong_response() {
 
     // Trigger the request
     bl.search_block(block_hash, PeerShouldHave::BlockAndBlobs(peer_id), &mut cx);
-    let id = rig.expect_block_request(response_type);
+    let id = rig.expect_lookup_request(response_type);
     // If we're in deneb, a blob request should have been triggered as well,
     // we don't require a response because we're generateing 0-blob blocks in this test.
     if matches!(fork_name, ForkName::Deneb) {
-        let _ = rig.expect_block_request(ResponseType::Blob);
+        let _ = rig.expect_lookup_request(ResponseType::Blob);
     }
 
     // Peer sends something else. It should be penalized.
@@ -390,7 +390,7 @@ fn test_single_block_lookup_wrong_response() {
         &cx,
     );
     rig.expect_penalty();
-    rig.expect_block_request(response_type); // should be retried
+    rig.expect_lookup_request(response_type); // should be retried
 
     // Send the stream termination. This should not produce an additional penalty.
     bl.single_lookup_response::<BlockRequestState<Current>>(id, peer_id, None, D, &cx);
@@ -411,11 +411,11 @@ fn test_single_block_lookup_failure() {
 
     // Trigger the request
     bl.search_block(block_hash, PeerShouldHave::BlockAndBlobs(peer_id), &mut cx);
-    let id = rig.expect_block_request(response_type);
+    let id = rig.expect_lookup_request(response_type);
     // If we're in deneb, a blob request should have been triggered as well,
     // we don't require a response because we're generateing 0-blob blocks in this test.
     if matches!(fork_name, ForkName::Deneb) {
-        let _ = rig.expect_block_request(ResponseType::Blob);
+        let _ = rig.expect_lookup_request(ResponseType::Blob);
     }
 
     // The request fails. RPC failures are handled elsewhere so we should not penalize the peer.
@@ -425,7 +425,7 @@ fn test_single_block_lookup_failure() {
         &cx,
         RPCError::UnsupportedProtocol,
     );
-    rig.expect_block_request(response_type);
+    rig.expect_lookup_request(response_type);
     rig.expect_empty_network();
 }
 
@@ -447,11 +447,11 @@ fn test_single_block_lookup_becomes_parent_request() {
         PeerShouldHave::BlockAndBlobs(peer_id),
         &mut cx,
     );
-    let id = rig.expect_block_request(response_type);
+    let id = rig.expect_lookup_request(response_type);
     // If we're in deneb, a blob request should have been triggered as well,
     // we don't require a response because we're generateing 0-blob blocks in this test.
     if matches!(fork_name, ForkName::Deneb) {
-        let _ = rig.expect_block_request(ResponseType::Blob);
+        let _ = rig.expect_lookup_request(ResponseType::Blob);
     }
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
@@ -1033,11 +1033,11 @@ fn test_single_block_lookup_ignored_response() {
         PeerShouldHave::BlockAndBlobs(peer_id),
         &mut cx,
     );
-    let id = rig.expect_block_request(response_type);
+    let id = rig.expect_lookup_request(response_type);
     // If we're in deneb, a blob request should have been triggered as well,
     // we don't require a response because we're generateing 0-blob blocks in this test.
     if matches!(fork_name, ForkName::Deneb) {
-        let _ = rig.expect_block_request(ResponseType::Blob);
+        let _ = rig.expect_lookup_request(ResponseType::Blob);
     }
 
     // The peer provides the correct block, should not be penalized. Now the block should be sent
@@ -1285,8 +1285,8 @@ mod deneb_only {
                             PeerShouldHave::BlockAndBlobs(peer_id),
                             &mut cx,
                         );
-                        let block_req_id = rig.expect_block_request(ResponseType::Block);
-                        let blob_req_id = rig.expect_block_request(ResponseType::Blob);
+                        let block_req_id = rig.expect_lookup_request(ResponseType::Block);
+                        let blob_req_id = rig.expect_lookup_request(ResponseType::Blob);
                         (Some(block_req_id), Some(blob_req_id), None, None)
                     }
                     RequestTrigger::GossipUnknownParentBlock => {
@@ -1306,12 +1306,12 @@ mod deneb_only {
                         block_root = child_root;
                         bl.search_child_block(
                             child_root,
-                            Some(ChildComponents::new(Some(child_block), None)),
+                            Some(CachedChildComponents::new(Some(child_block), None)),
                             &[PeerShouldHave::Neither(peer_id)],
                             &mut cx,
                         );
 
-                        let blob_req_id = rig.expect_block_request(ResponseType::Blob);
+                        let blob_req_id = rig.expect_lookup_request(ResponseType::Blob);
                         rig.expect_empty_network(); // expect no block request
                         bl.search_parent(slot, child_root, parent_root, peer_id, &mut cx);
                         let parent_block_req_id = rig.expect_parent_request(ResponseType::Block);
@@ -1344,13 +1344,13 @@ mod deneb_only {
                         *blobs.index_mut(0) = Some(child_blob);
                         bl.search_child_block(
                             child_root,
-                            Some(ChildComponents::new(None, Some(blobs))),
+                            Some(CachedChildComponents::new(None, Some(blobs))),
                             &[PeerShouldHave::Neither(peer_id)],
                             &mut cx,
                         );
 
-                        let block_req_id = rig.expect_block_request(ResponseType::Block);
-                        let blobs_req_id = rig.expect_block_request(ResponseType::Blob);
+                        let block_req_id = rig.expect_lookup_request(ResponseType::Block);
+                        let blobs_req_id = rig.expect_lookup_request(ResponseType::Blob);
                         rig.expect_empty_network(); // expect no block request
                         bl.search_parent(slot, child_root, parent_root, peer_id, &mut cx);
                         let parent_block_req_id = rig.expect_parent_request(ResponseType::Block);
@@ -1364,8 +1364,8 @@ mod deneb_only {
                     }
                     RequestTrigger::GossipUnknownBlockOrBlob => {
                         bl.search_block(block_root, PeerShouldHave::Neither(peer_id), &mut cx);
-                        let block_req_id = rig.expect_block_request(ResponseType::Block);
-                        let blob_req_id = rig.expect_block_request(ResponseType::Blob);
+                        let block_req_id = rig.expect_lookup_request(ResponseType::Block);
+                        let blob_req_id = rig.expect_lookup_request(ResponseType::Blob);
                         (Some(block_req_id), Some(blob_req_id), None, None)
                     }
                 };
@@ -1646,12 +1646,12 @@ mod deneb_only {
             self
         }
         fn expect_block_request(mut self) -> Self {
-            let id = self.rig.expect_block_request(ResponseType::Block);
+            let id = self.rig.expect_lookup_request(ResponseType::Block);
             self.block_req_id = Some(id);
             self
         }
         fn expect_blobs_request(mut self) -> Self {
-            let id = self.rig.expect_block_request(ResponseType::Blob);
+            let id = self.rig.expect_lookup_request(ResponseType::Blob);
             self.blob_req_id = Some(id);
             self
         }
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index d61e34c21ca..f823e127092 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -44,7 +44,7 @@ use crate::status::ToStatusMessage;
 use crate::sync::block_lookups::common::{Current, Parent};
 use crate::sync::block_lookups::delayed_lookup;
 use crate::sync::block_lookups::delayed_lookup::DelayedLookupMessage;
-use crate::sync::block_lookups::{BlobRequestState, BlockRequestState, ChildComponents};
+use crate::sync::block_lookups::{BlobRequestState, BlockRequestState, CachedChildComponents};
 use crate::sync::range_sync::ByRangeRequestType;
 use beacon_chain::block_verification_types::AsBlock;
 use beacon_chain::block_verification_types::RpcBlock;
@@ -667,7 +667,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                     block_root,
                     parent_root,
                     blob_slot,
-                    Some(ChildComponents::new(None, Some(blobs))),
+                    Some(CachedChildComponents::new(None, Some(blobs))),
                 );
             }
             SyncMessage::UnknownBlockHashFromAttestation(peer_id, block_hash) => {
@@ -776,7 +776,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         block_root: Hash256,
         parent_root: Hash256,
         slot: Slot,
-        parent_components: Option<ChildComponents<T::EthSpec>>,
+        parent_components: Option<CachedChildComponents<T::EthSpec>>,
     ) {
         if self.should_search_for_block(slot, &peer_id) {
             self.block_lookups.search_parent(
diff --git a/beacon_node/network/src/sync/mod.rs b/beacon_node/network/src/sync/mod.rs
index 23e055f60af..b6ed1b3c3d5 100644
--- a/beacon_node/network/src/sync/mod.rs
+++ b/beacon_node/network/src/sync/mod.rs
@@ -9,6 +9,6 @@ mod network_context;
 mod peer_sync_info;
 mod range_sync;
 
-pub use block_lookups::ChildComponents;
+pub use block_lookups::CachedChildComponents;
 pub use manager::{BatchProcessResult, SyncMessage};
 pub use range_sync::{BatchOperationOutcome, ChainId};
diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs
index adc9469d71f..df48005e473 100644
--- a/beacon_node/network/src/sync/network_context.rs
+++ b/beacon_node/network/src/sync/network_context.rs
@@ -443,8 +443,8 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         lookup_type: LookupType,
     ) -> Result<(), &'static str> {
         let sync_id = match lookup_type {
-            LookupType::Current => SyncRequestId::SingleBlock { id },
-            LookupType::Parent => SyncRequestId::ParentLookup { id },
+            LookupType::Current => SyncRequestId::SingleBlob { id },
+            LookupType::Parent => SyncRequestId::ParentLookupBlob { id },
         };
         let request_id = RequestId::Sync(sync_id);
 

From 335e57d0f8ad49a2443d614e2ca294da7995840a Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@GMAIL.com>
Date: Fri, 4 Aug 2023 09:43:02 -0400
Subject: [PATCH 15/18] Update
 beacon_node/network/src/sync/block_lookups/mod.rs

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>
---
 beacon_node/network/src/sync/block_lookups/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 0c1bc4e15bd..f04d8cbf920 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -338,7 +338,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     /* Lookup responses */
 
     /// Get a single block lookup by its ID. This method additionally ensures the `req_counter`
-    /// matches the current `req_counter` for the lookup. This any stale responses from requests
+    /// matches the current `req_counter` for the lookup. This ensures any stale responses from requests
     /// that have been retried are ignored.
     fn get_single_lookup<R: RequestState<Current, T>>(
         &mut self,

From 8404cc8ef6877f87918ffe496a07e8367c4a6df3 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@GMAIL.com>
Date: Fri, 4 Aug 2023 09:43:15 -0400
Subject: [PATCH 16/18] Update
 beacon_node/network/src/sync/block_lookups/mod.rs

Co-authored-by: Jimmy Chen <jchen.tc@gmail.com>
---
 beacon_node/network/src/sync/block_lookups/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index f04d8cbf920..c4d9e8287e5 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -1304,7 +1304,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                         lookup.handle_consistency_failure(cx);
                         if let Err(e) = lookup.request_block_and_blobs(cx) {
                             debug!(self.log,
-                                "Failed to request block and blobs, droppingn lookup";
+                                "Failed to request block and blobs, dropping lookup";
                                 "error" => ?e
                             );
                             self.single_block_lookups.remove(&id);

From 4db34e9d7cd90db826eed0332e41045f0d7761ec Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Fri, 4 Aug 2023 10:24:41 -0400
Subject: [PATCH 17/18] more pr feedback, fix availability check error handling

---
 .../src/data_availability_checker.rs          |  1 -
 .../gossip_methods.rs                         |  1 -
 .../network/src/sync/block_lookups/common.rs  |  4 +-
 .../network/src/sync/block_lookups/mod.rs     | 87 +++++++++++--------
 .../src/sync/block_lookups/parent_lookup.rs   |  6 +-
 .../sync/block_lookups/single_block_lookup.rs | 20 ++---
 beacon_node/network/src/sync/manager.rs       | 10 ++-
 7 files changed, 74 insertions(+), 55 deletions(-)

diff --git a/beacon_node/beacon_chain/src/data_availability_checker.rs b/beacon_node/beacon_chain/src/data_availability_checker.rs
index 3e7685efd81..f6130d26ec2 100644
--- a/beacon_node/beacon_chain/src/data_availability_checker.rs
+++ b/beacon_node/beacon_chain/src/data_availability_checker.rs
@@ -41,7 +41,6 @@ pub enum AvailabilityCheckError {
         num_blobs: usize,
     },
     MissingBlobs,
-    TxKzgCommitmentMismatch(String),
     KzgCommitmentMismatch {
         blob_index: u64,
     },
diff --git a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
index 97cd82e7190..5b3a3ba42d0 100644
--- a/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
+++ b/beacon_node/network/src/network_beacon_processor/gossip_methods.rs
@@ -1169,7 +1169,6 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     AvailabilityCheckError::Kzg(_)
                     | AvailabilityCheckError::KzgVerificationFailed
                     | AvailabilityCheckError::NumBlobsMismatch { .. }
-                    | AvailabilityCheckError::TxKzgCommitmentMismatch(_)
                     | AvailabilityCheckError::BlobIndexInvalid(_)
                     | AvailabilityCheckError::UnorderedBlobs { .. }
                     | AvailabilityCheckError::BlockBlobRootMismatch { .. }
diff --git a/beacon_node/network/src/sync/block_lookups/common.rs b/beacon_node/network/src/sync/block_lookups/common.rs
index aa12acc12c7..4f071a04358 100644
--- a/beacon_node/network/src/sync/block_lookups/common.rs
+++ b/beacon_node/network/src/sync/block_lookups/common.rs
@@ -326,7 +326,7 @@ impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlockRequestState<L>
         verified_response: Arc<SignedBeaconBlock<T::EthSpec>>,
         components: &mut CachedChildComponents<T::EthSpec>,
     ) {
-        components.add_unknown_parent_block(verified_response);
+        components.add_cached_child_block(verified_response);
     }
 
     fn verified_to_reconstructed(
@@ -432,7 +432,7 @@ impl<L: Lookup, T: BeaconChainTypes> RequestState<L, T> for BlobRequestState<L,
         verified_response: FixedBlobSidecarList<T::EthSpec>,
         components: &mut CachedChildComponents<T::EthSpec>,
     ) {
-        components.add_unknown_parent_blobs(verified_response);
+        components.add_cached_child_blobs(verified_response);
     }
 
     fn verified_to_reconstructed(
diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 0c1bc4e15bd..36389223eab 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -12,7 +12,7 @@ use crate::sync::block_lookups::single_block_lookup::{
 };
 use crate::sync::manager::{Id, SingleLookupReqId};
 use beacon_chain::block_verification_types::{AsBlock, RpcBlock};
-use beacon_chain::data_availability_checker::DataAvailabilityChecker;
+use beacon_chain::data_availability_checker::{AvailabilityCheckError, DataAvailabilityChecker};
 use beacon_chain::validator_monitor::timestamp_now;
 use beacon_chain::{AvailabilityProcessingStatus, BeaconChainTypes, BlockError};
 pub use common::Current;
@@ -43,7 +43,7 @@ mod single_block_lookup;
 #[cfg(test)]
 mod tests;
 
-pub type DownloadedBlocks<T> = (Hash256, RpcBlock<T>);
+pub type DownloadedBlock<T> = (Hash256, RpcBlock<T>);
 
 const FAILED_CHAINS_CACHE_EXPIRY_SECONDS: u64 = 60;
 pub const SINGLE_BLOCK_LOOKUP_MAX_ATTEMPTS: u8 = 3;
@@ -155,11 +155,11 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn search_child_block(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<CachedChildComponents<T::EthSpec>>,
+        child_components: Option<CachedChildComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) {
-        let lookup = self.new_current_lookup(block_root, parent_components, peer_source, cx);
+        let lookup = self.new_current_lookup(block_root, child_components, peer_source, cx);
         if let Some(lookup) = lookup {
             self.trigger_single_lookup(lookup, cx);
         }
@@ -175,11 +175,11 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn search_child_delayed(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<CachedChildComponents<T::EthSpec>>,
+        child_components: Option<CachedChildComponents<T::EthSpec>>,
         peer_source: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) {
-        let lookup = self.new_current_lookup(block_root, parent_components, peer_source, cx);
+        let lookup = self.new_current_lookup(block_root, child_components, peer_source, cx);
         if let Some(lookup) = lookup {
             self.add_single_lookup(lookup)
         }
@@ -235,7 +235,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     pub fn new_current_lookup(
         &mut self,
         block_root: Hash256,
-        parent_components: Option<CachedChildComponents<T::EthSpec>>,
+        child_components: Option<CachedChildComponents<T::EthSpec>>,
         peers: &[PeerShouldHave],
         cx: &mut SyncNetworkContext<T>,
     ) -> Option<SingleBlockLookup<Current, T>> {
@@ -246,7 +246,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             .find(|(_id, lookup)| lookup.is_for_block(block_root))
         {
             lookup.add_peers(peers);
-            if let Some(components) = parent_components {
+            if let Some(components) = child_components {
                 lookup.add_child_components(components);
             }
             return None;
@@ -280,7 +280,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
 
         Some(SingleBlockLookup::new(
             block_root,
-            parent_components,
+            child_components,
             peers,
             self.da_checker.clone(),
             cx.next_id(),
@@ -397,7 +397,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
             }
             Err(e) => {
                 debug!(self.log,
-                    "Single lookup retry failed";
+                    "Single lookup request failed";
                     "error" => ?e,
                     "block_root" => ?expected_block_root,
                 );
@@ -503,7 +503,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 // we should penalize the blobs peer because they did not provide all blobs on the
                 // initial request.
                 if lookup.both_components_downloaded() {
-                    lookup.penalize_lazy_blob_peer(cx);
+                    lookup.penalize_blob_peer(false, cx);
                     lookup
                         .blob_request_state
                         .state
@@ -602,12 +602,12 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
     fn parent_lookup_response_inner<R: RequestState<Parent, T>>(
         &mut self,
         peer_id: PeerId,
-        block: Option<R::ResponseType>,
+        response: Option<R::ResponseType>,
         seen_timestamp: Duration,
         cx: &SyncNetworkContext<T>,
         parent_lookup: &mut ParentLookup<T>,
     ) -> Result<(), RequestError> {
-        match parent_lookup.verify_block::<R>(block, &mut self.failed_chains) {
+        match parent_lookup.verify_response::<R>(response, &mut self.failed_chains) {
             Ok(Some(verified_response)) => {
                 self.handle_verified_response::<Parent, R>(
                     seen_timestamp,
@@ -892,7 +892,7 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
 
         request_state.get_state_mut().component_processed = true;
         if lookup.both_components_processed() {
-            lookup.penalize_lazy_blob_peer(cx);
+            lookup.penalize_blob_peer(false, cx);
 
             // Try it again if possible.
             lookup
@@ -944,28 +944,45 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
                 return Ok(None);
             }
             BlockError::AvailabilityCheck(e) => {
-                warn!(self.log, "Availability check failure"; "root" => %root, "peer_id" => %peer_id, "error" => ?e);
-                lookup.handle_availability_check_failure(cx);
-                lookup.request_block_and_blobs(cx)?
-            }
-            BlockError::BlobValidation(_) => {
-                warn!(self.log, "Blob validation failure"; "root" => %root, "peer_id" => %peer_id);
-                if let Ok(blob_peer) = lookup.blob_request_state.state.processing_peer() {
-                    cx.report_peer(
-                        blob_peer.to_peer_id(),
-                        PeerAction::MidToleranceError,
-                        "single_block_failure",
-                    );
-                    lookup
-                        .blob_request_state
-                        .state
-                        .remove_peer_if_useless(blob_peer.as_peer_id());
+                match e {
+                    // Internal error.
+                    AvailabilityCheckError::KzgNotInitialized
+                    | AvailabilityCheckError::SszTypes(_)
+                    | AvailabilityCheckError::MissingBlobs
+                    | AvailabilityCheckError::UnorderedBlobs { .. }
+                    | AvailabilityCheckError::StoreError(_)
+                    | AvailabilityCheckError::DecodeError(_) => {
+                        warn!(self.log, "Internal availability check failure"; "root" => %root, "peer_id" => %peer_id, "error" => ?e);
+                        lookup
+                            .block_request_state
+                            .state
+                            .register_failure_downloading();
+                        lookup
+                            .blob_request_state
+                            .state
+                            .register_failure_downloading();
+                        lookup.request_block_and_blobs(cx)?
+                    }
+
+                    // Invalid block and blob comparison.
+                    AvailabilityCheckError::NumBlobsMismatch { .. }
+                    | AvailabilityCheckError::KzgCommitmentMismatch { .. }
+                    | AvailabilityCheckError::BlockBlobRootMismatch { .. }
+                    | AvailabilityCheckError::BlockBlobSlotMismatch { .. } => {
+                        warn!(self.log, "Availability check failure in consistency"; "root" => %root, "peer_id" => %peer_id, "error" => ?e);
+                        lookup.handle_consistency_failure(cx);
+                        lookup.request_block_and_blobs(cx)?
+                    }
+
+                    // Malicious errors.
+                    AvailabilityCheckError::Kzg(_)
+                    | AvailabilityCheckError::BlobIndexInvalid(_)
+                    | AvailabilityCheckError::KzgVerificationFailed => {
+                        warn!(self.log, "Availability check failure"; "root" => %root, "peer_id" => %peer_id, "error" => ?e);
+                        lookup.handle_availability_check_failure(cx);
+                        lookup.request_block_and_blobs(cx)?
+                    }
                 }
-                lookup
-                    .blob_request_state
-                    .state
-                    .register_failure_processing();
-                lookup.request_block_and_blobs(cx)?
             }
             other => {
                 warn!(self.log, "Peer sent invalid block in single block lookup"; "root" => %root, "error" => ?other, "peer_id" => %peer_id);
diff --git a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
index b94a3be71ea..56c509c1640 100644
--- a/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/parent_lookup.rs
@@ -1,5 +1,5 @@
 use super::single_block_lookup::{LookupRequestError, LookupVerifyError, SingleBlockLookup};
-use super::{DownloadedBlocks, PeerShouldHave};
+use super::{DownloadedBlock, PeerShouldHave};
 use crate::sync::block_lookups::common::Parent;
 use crate::sync::block_lookups::common::RequestState;
 use crate::sync::{manager::SLOT_IMPORT_TOLERANCE, network_context::SyncNetworkContext};
@@ -25,7 +25,7 @@ pub(crate) struct ParentLookup<T: BeaconChainTypes> {
     /// The root of the block triggering this parent request.
     chain_hash: Hash256,
     /// The blocks that have currently been downloaded.
-    downloaded_blocks: Vec<DownloadedBlocks<T::EthSpec>>,
+    downloaded_blocks: Vec<DownloadedBlock<T::EthSpec>>,
     /// Request of the last parent.
     pub current_parent_request: SingleBlockLookup<Parent, T>,
 }
@@ -186,7 +186,7 @@ impl<T: BeaconChainTypes> ParentLookup<T> {
 
     /// Verifies that the received block is what we requested. If so, parent lookup now waits for
     /// the processing result of the block.
-    pub fn verify_block<R: RequestState<Parent, T>>(
+    pub fn verify_response<R: RequestState<Parent, T>>(
         &mut self,
         block: Option<R::ResponseType>,
         failed_chains: &mut lru_cache::LRUTimeCache<Hash256>,
diff --git a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
index fef676c8719..16badf61372 100644
--- a/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
+++ b/beacon_node/network/src/sync/block_lookups/single_block_lookup.rs
@@ -172,9 +172,9 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
                 downloaded_blobs,
             } = components;
             if let Some(block) = downloaded_block {
-                existing_components.add_unknown_parent_block(block);
+                existing_components.add_cached_child_block(block);
             }
-            existing_components.add_unknown_parent_blobs(downloaded_blobs);
+            existing_components.add_cached_child_blobs(downloaded_blobs);
         } else {
             self.cached_child_components = Some(components);
         }
@@ -283,13 +283,13 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
     /// Penalizes a blob peer if it should have blobs but didn't return them to us. Does not penalize
     /// a peer who we request blobs from based on seeing a block or blobs over gossip. This may
     /// have been a benign failure.
-    pub fn penalize_lazy_blob_peer(&mut self, cx: &SyncNetworkContext<T>) {
+    pub fn penalize_blob_peer(&mut self, penalize_always: bool, cx: &SyncNetworkContext<T>) {
         if let Ok(blob_peer) = self.blob_request_state.state.processing_peer() {
-            if let PeerShouldHave::BlockAndBlobs(blob_peer) = blob_peer {
+            if penalize_always || matches!(blob_peer, PeerShouldHave::BlockAndBlobs(_)) {
                 cx.report_peer(
-                    blob_peer,
+                    blob_peer.to_peer_id(),
                     PeerAction::MidToleranceError,
-                    "single_block_failure",
+                    "single_blob_failure",
                 );
             }
             self.blob_request_state
@@ -301,7 +301,7 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
     /// This failure occurs on download, so register a failure downloading, penalize the peer if
     /// necessary and clear the blob cache.
     pub fn handle_consistency_failure(&mut self, cx: &SyncNetworkContext<T>) {
-        self.penalize_lazy_blob_peer(cx);
+        self.penalize_blob_peer(false, cx);
         if let Some(cached_child) = self.cached_child_components.as_mut() {
             cached_child.clear_blobs();
         }
@@ -311,7 +311,7 @@ impl<L: Lookup, T: BeaconChainTypes> SingleBlockLookup<L, T> {
     /// This failure occurs after processing, so register a failure processing, penalize the peer if
     /// necessary and clear the blob cache.
     pub fn handle_availability_check_failure(&mut self, cx: &SyncNetworkContext<T>) {
-        self.penalize_lazy_blob_peer(cx);
+        self.penalize_blob_peer(true, cx);
         if let Some(cached_child) = self.cached_child_components.as_mut() {
             cached_child.clear_blobs();
         }
@@ -411,11 +411,11 @@ impl<E: EthSpec> CachedChildComponents<E> {
         self.downloaded_blobs = FixedBlobSidecarList::default();
     }
 
-    pub fn add_unknown_parent_block(&mut self, block: Arc<SignedBeaconBlock<E>>) {
+    pub fn add_cached_child_block(&mut self, block: Arc<SignedBeaconBlock<E>>) {
         self.downloaded_block = Some(block);
     }
 
-    pub fn add_unknown_parent_blobs(&mut self, blobs: FixedBlobSidecarList<E>) {
+    pub fn add_cached_child_blobs(&mut self, blobs: FixedBlobSidecarList<E>) {
         for (index, blob_opt) in self.downloaded_blobs.iter_mut().enumerate() {
             if let Some(Some(downloaded_blob)) = blobs.get(index) {
                 *blob_opt = Some(downloaded_blob.clone());
diff --git a/beacon_node/network/src/sync/manager.rs b/beacon_node/network/src/sync/manager.rs
index f823e127092..579877f4b39 100644
--- a/beacon_node/network/src/sync/manager.rs
+++ b/beacon_node/network/src/sync/manager.rs
@@ -660,6 +660,10 @@ impl<T: BeaconChainTypes> SyncManager<T> {
                 let block_root = blob.block_root;
                 let parent_root = blob.block_parent_root;
                 let blob_index = blob.index;
+                if blob_index >= T::EthSpec::max_blobs_per_block() as u64 {
+                    warn!(self.log, "Peer sent blob with invalid index"; "index" => blob_index, "peer_id" => %peer_id);
+                    return;
+                }
                 let mut blobs = FixedBlobSidecarList::default();
                 *blobs.index_mut(blob_index as usize) = Some(blob);
                 self.handle_unknown_parent(
@@ -776,7 +780,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
         block_root: Hash256,
         parent_root: Hash256,
         slot: Slot,
-        parent_components: Option<CachedChildComponents<T::EthSpec>>,
+        child_components: Option<CachedChildComponents<T::EthSpec>>,
     ) {
         if self.should_search_for_block(slot, &peer_id) {
             self.block_lookups.search_parent(
@@ -789,7 +793,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             if self.should_delay_lookup(slot) {
                 self.block_lookups.search_child_delayed(
                     block_root,
-                    parent_components,
+                    child_components,
                     &[PeerShouldHave::Neither(peer_id)],
                     &mut self.network,
                 );
@@ -802,7 +806,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
             } else {
                 self.block_lookups.search_child_block(
                     block_root,
-                    parent_components,
+                    child_components,
                     &[PeerShouldHave::Neither(peer_id)],
                     &mut self.network,
                 );

From b8c1e53bb19e62596b03ff1a28537226d413b036 Mon Sep 17 00:00:00 2001
From: realbigsean <seananderson33@gmail.com>
Date: Mon, 7 Aug 2023 12:56:55 -0400
Subject: [PATCH 18/18] improve block component processed log

---
 beacon_node/network/src/sync/block_lookups/mod.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/beacon_node/network/src/sync/block_lookups/mod.rs b/beacon_node/network/src/sync/block_lookups/mod.rs
index 7943f6649b3..53670e11855 100644
--- a/beacon_node/network/src/sync/block_lookups/mod.rs
+++ b/beacon_node/network/src/sync/block_lookups/mod.rs
@@ -832,7 +832,9 @@ impl<T: BeaconChainTypes> BlockLookups<T> {
         };
         debug!(
             self.log,
-            "Block component processed for single block lookup not present"
+            "Block component processed for lookup";
+            "response_type" => ?R::response_type(),
+            "result" => ?result,
         );
 
         match result {