renames, remove , wrap BlockWrapper enum to make descontruction private

beacon_node/network/src/sync/range_sync/batch.rs

@@ -4,10 +4,9 @@ use lighthouse_network::PeerId;
 use std::collections::HashSet;
 use std::hash::{Hash, Hasher};
 use std::ops::Sub;
-use std::sync::Arc;
 use strum::Display;
 use types::signed_block_and_blobs::BlockWrapper;
-use types::{Epoch, EthSpec, SignedBeaconBlock, SignedBeaconBlockAndBlobsSidecar, Slot};
+use types::{Epoch, EthSpec, Slot};
 
 /// The number of times to retry a batch before it is considered failed.
 const MAX_BATCH_DOWNLOAD_ATTEMPTS: u8 = 5;
@@ -16,36 +15,12 @@ const MAX_BATCH_DOWNLOAD_ATTEMPTS: u8 = 5;
 /// after `MAX_BATCH_PROCESSING_ATTEMPTS` times, it is considered faulty.
 const MAX_BATCH_PROCESSING_ATTEMPTS: u8 = 3;
 
-pub enum BatchTy<T: EthSpec> {
-    Blocks(Vec<Arc<SignedBeaconBlock<T>>>),
-    BlocksAndBlobs(Vec<SignedBeaconBlockAndBlobsSidecar<T>>),
-}
-
-impl<T: EthSpec> BatchTy<T> {
-    pub fn into_wrapped_blocks(self) -> Vec<BlockWrapper<T>> {
-        match self {
-            BatchTy::Blocks(blocks) => blocks
-                .into_iter()
-                .map(|block| BlockWrapper::Block(block))
-                .collect(),
-            BatchTy::BlocksAndBlobs(block_sidecar_pair) => block_sidecar_pair
-                .into_iter()
-                .map(|block_sidecar_pair| BlockWrapper::BlockAndBlob(block_sidecar_pair))
-                .collect(),
-        }
-    }
-}
-
-/// Error representing a batch with mixed block types.
-#[derive(Debug)]
-pub struct MixedBlockTyErr;
-
 /// Type of expected batch.
 #[derive(Debug, Copy, Clone, Display)]
 #[strum(serialize_all = "snake_case")]
-pub enum ExpectedBatchTy {
-    OnlyBlockBlobs,
-    OnlyBlock,
+pub enum ByRangeRequestType {
+    BlocksAndBlobs,
+    Blocks,
 }
 
 /// Allows customisation of the above constants used in other sync methods such as BackFillSync.
@@ -131,7 +106,7 @@ pub struct BatchInfo<T: EthSpec, B: BatchConfig = RangeSyncBatchConfig> {
     /// State of the batch.
     state: BatchState<T>,
     /// Whether this batch contains all blocks or all blocks and blobs.
-    batch_type: ExpectedBatchTy,
+    batch_type: ByRangeRequestType,
     /// Pin the generic
     marker: std::marker::PhantomData<B>,
 }
@@ -180,7 +155,7 @@ impl<T: EthSpec, B: BatchConfig> BatchInfo<T, B> {
     /// fork boundary will be of mixed type (all blocks and one last blockblob), and I don't want to
     /// deal with this for now.
     /// This means finalization might be slower in eip4844
-    pub fn new(start_epoch: &Epoch, num_of_epochs: u64, batch_type: ExpectedBatchTy) -> Self {
+    pub fn new(start_epoch: &Epoch, num_of_epochs: u64, batch_type: ByRangeRequestType) -> Self {
         let start_slot = start_epoch.start_slot(T::slots_per_epoch());
         let end_slot = start_slot + num_of_epochs * T::slots_per_epoch();
         BatchInfo {
@@ -243,7 +218,7 @@ impl<T: EthSpec, B: BatchConfig> BatchInfo<T, B> {
     }
 
     /// Returns a BlocksByRange request associated with the batch.
-    pub fn to_blocks_by_range_request(&self) -> (BlocksByRangeRequest, ExpectedBatchTy) {
+    pub fn to_blocks_by_range_request(&self) -> (BlocksByRangeRequest, ByRangeRequestType) {
         (
             BlocksByRangeRequest {
                 start_slot: self.start_slot.into(),
@@ -408,30 +383,11 @@ impl<T: EthSpec, B: BatchConfig> BatchInfo<T, B> {
         }
     }
 
-    pub fn start_processing(&mut self) -> Result<BatchTy<T>, WrongState> {
+    pub fn start_processing(&mut self) -> Result<Vec<BlockWrapper<T>>, WrongState> {
         match self.state.poison() {
             BatchState::AwaitingProcessing(peer, blocks) => {
                 self.state = BatchState::Processing(Attempt::new::<B, T>(peer, &blocks));
-                match self.batch_type {
-                    ExpectedBatchTy::OnlyBlockBlobs => {
-                        let blocks = blocks.into_iter().map(|block| {
-                            let BlockWrapper::BlockAndBlob(block_and_blob) = block else {
-                                panic!("Batches should never have a mixed type. This is a bug. Contact D")
-                            };
-                            block_and_blob
-                        }).collect();
-                        Ok(BatchTy::BlocksAndBlobs(blocks))
-                    }
-                    ExpectedBatchTy::OnlyBlock => {
-                        let blocks = blocks.into_iter().map(|block| {
-                            let BlockWrapper::Block(block) = block else {
-                                panic!("Batches should never have a mixed type. This is a bug. Contact D")
-                            };
-                            block
-                        }).collect();
-                        Ok(BatchTy::Blocks(blocks))
-                    }
-                }
+                Ok(blocks)
             }
             BatchState::Poisoned => unreachable!("Poisoned batch"),
             other => {

beacon_node/network/src/sync/range_sync/chain.rs

@@ -332,7 +332,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
         let process_id = ChainSegmentProcessId::RangeBatchId(self.id, batch_id, count_unrealized);
         self.current_processing_batch = Some(batch_id);
 
-        let work_event = BeaconWorkEvent::chain_segment(process_id, blocks.into_wrapped_blocks());
+        let work_event = BeaconWorkEvent::chain_segment(process_id, blocks);
 
         if let Err(e) = beacon_processor_send.try_send(work_event) {
             crit!(self.log, "Failed to send chain segment to processor."; "msg" => "process_batch",

beacon_node/network/src/sync/range_sync/mod.rs

@@ -9,8 +9,8 @@ mod range;
 mod sync_type;
 
 pub use batch::{
-    BatchConfig, BatchInfo, BatchOperationOutcome, BatchProcessingResult, BatchState, BatchTy,
-    ExpectedBatchTy,
+    BatchConfig, BatchInfo, BatchOperationOutcome, BatchProcessingResult, BatchState,
+    ByRangeRequestType,
 };
 pub use chain::{BatchId, ChainId, EPOCHS_PER_BATCH};
 pub use range::RangeSync;

beacon_node/network/src/sync/range_sync/range.rs

@@ -373,7 +373,7 @@ where
 #[cfg(test)]
 mod tests {
     use crate::service::RequestId;
-    use crate::sync::range_sync::ExpectedBatchTy;
+    use crate::sync::range_sync::ByRangeRequestType;
     use crate::NetworkMessage;
 
     use super::*;
@@ -686,7 +686,7 @@ mod tests {
         let (peer1, local_info, head_info) = rig.head_peer();
         range.add_peer(&mut rig.cx, local_info, peer1, head_info);
         let ((chain1, batch1), id1) = match rig.grab_request(&peer1).0 {
-            RequestId::Sync(crate::sync::manager::RequestId::RangeSync { id }) => {
+            RequestId::Sync(crate::sync::manager::RequestId::RangeBlocks { id }) => {
                 (rig.cx.range_sync_response(id, true).unwrap(), id)
             }
             other => panic!("unexpected request {:?}", other),
@@ -705,7 +705,7 @@ mod tests {
         let (peer2, local_info, finalized_info) = rig.finalized_peer();
         range.add_peer(&mut rig.cx, local_info, peer2, finalized_info);
         let ((chain2, batch2), id2) = match rig.grab_request(&peer2).0 {
-            RequestId::Sync(crate::sync::manager::RequestId::RangeSync { id }) => {
+            RequestId::Sync(crate::sync::manager::RequestId::RangeBlocks { id }) => {
                 (rig.cx.range_sync_response(id, true).unwrap(), id)
             }
             other => panic!("unexpected request {:?}", other),