cleanup

Author: ksn6

ledger/src/blockstore.rs

@@ -4099,18 +4099,23 @@ impl Blockstore {
             .collect()
     }
 
-    /// Fetch the components corresponding to all of the shred indices in `completed_ranges`
+    /// Helper function to process shreds in `completed_ranges` and apply a transformation
+    /// to the resulting block components.
     /// This function takes advantage of the fact that `completed_ranges` are both
     /// contiguous and in sorted order. To clarify, suppose completed_ranges is as follows:
     ///   completed_ranges = [..., (s_i..e_i), (s_i+1..e_i+1), ...]
     /// Then, the following statements are true:
     ///   s_i < e_i == s_i+1 < e_i+1
-    fn get_slot_components_in_block(
+    fn process_slot_data_in_block<T, F>(
         &self,
         slot: Slot,
         completed_ranges: CompletedRanges,
         slot_meta: Option<&SlotMeta>,
-    ) -> Result<Vec<BlockComponent>> {
+        transform: F,
+    ) -> Result<Vec<T>>
+    where
+        F: Fn(Vec<BlockComponent>) -> Result<Vec<T>>,
+    {
         debug_assert!(completed_ranges
             .iter()
             .tuple_windows()
@@ -4143,7 +4148,7 @@ impl Blockstore {
         completed_ranges
             .into_iter()
             .map(|Range { start, end }| end - start)
-            .map(move |num_shreds| {
+            .map(|num_shreds| {
                 shreds
                     .by_ref()
                     .take(num_shreds as usize)
@@ -4156,9 +4161,18 @@ impl Blockstore {
                     .and_then(|payload| {
                         // TODO(karthik): if Alpenglow flag is disabled, return an error on special
                         // EntryBatches.
-                        BlockComponent::from_bytes_multiple(&payload).map_err(|e| {
+                        let components = BlockComponent::from_bytes_multiple(&payload).map_err(
+                            |e| {
+                                BlockstoreError::InvalidShredData(Box::new(
+                                    bincode::ErrorKind::Custom(format!(
+                                        "could not reconstruct block components: {e:?}"
+                                    )),
+                                ))
+                            },
+                        )?;
+                        transform(components).map_err(|e| {
                             BlockstoreError::InvalidShredData(Box::new(bincode::ErrorKind::Custom(
-                                format!("could not reconstruct entries: {e:?}"),
+                                format!("could not transform block components: {e:?}"),
                             )))
                         })
                     })
@@ -4167,6 +4181,21 @@ impl Blockstore {
             .collect()
     }
 
+    /// Fetch the components corresponding to all of the shred indices in `completed_ranges`
+    /// This function takes advantage of the fact that `completed_ranges` are both
+    /// contiguous and in sorted order. To clarify, suppose completed_ranges is as follows:
+    ///   completed_ranges = [..., (s_i..e_i), (s_i+1..e_i+1), ...]
+    /// Then, the following statements are true:
+    ///   s_i < e_i == s_i+1 < e_i+1
+    fn get_slot_components_in_block(
+        &self,
+        slot: Slot,
+        completed_ranges: CompletedRanges,
+        slot_meta: Option<&SlotMeta>,
+    ) -> Result<Vec<BlockComponent>> {
+        self.process_slot_data_in_block(slot, completed_ranges, slot_meta, Ok)
+    }
+
     /// Fetch the entries corresponding to all of the shred indices in `completed_ranges`
     /// This function takes advantage of the fact that `completed_ranges` are both
     /// contiguous and in sorted order. To clarify, suppose completed_ranges is as follows:
@@ -4179,12 +4208,13 @@ impl Blockstore {
         completed_ranges: CompletedRanges,
         slot_meta: Option<&SlotMeta>,
     ) -> Result<Vec<Entry>> {
-        Ok(self
-            .get_slot_components_in_block(slot, completed_ranges, slot_meta)?
-            .into_iter()
-            .filter_map(|c| c.as_entry_batch_owned())
-            .flatten()
-            .collect_vec())
+        self.process_slot_data_in_block(slot, completed_ranges, slot_meta, |cs| {
+            Ok(cs
+                .into_iter()
+                .filter_map(|bc| bc.as_entry_batch_owned())
+                .flatten()
+                .collect_vec())
+        })
     }
 
     pub fn get_entries_in_data_block(