Fix for #7122 Avoid attempting to serve BlobsByRange RPC requests on Fulu slots

beacon_node/network/src/network_beacon_processor/rpc_methods.rs

@@ -880,6 +880,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             "Received BlobsByRange Request"
         );
 
+        // Check Deneb is enabled. Blobs are available since then.
         let request_start_slot = Slot::from(req.start_slot);
 
         let data_availability_boundary_slot = match self.chain.data_availability_boundary() {
@@ -917,6 +918,17 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
             };
         }
 
+        // Check Fulu/PeerDAS is enabled. Blobs are not stored since then.
+        // Only need to check if the last slot is a Fulu slot or above.
+        let request_end_slot = Slot::from(req.start_slot + req.count);
+        let request_end_epoch = request_end_slot.epoch(T::EthSpec::slots_per_epoch());
+        if self.chain.spec.is_peer_das_enabled_for_epoch(request_end_epoch) {
+            return Err((
+                RpcErrorResponse::InvalidRequest,
+                "Req including Fulu slots",
+            ))
+        }
+
         let block_roots =
             self.get_block_roots_for_slot_range(req.start_slot, req.count, "BlobsByRange")?;
 

beacon_node/network/src/network_beacon_processor/tests.rs

@@ -1,4 +1,4 @@
-#![cfg(not(debug_assertions))] // Tests are too slow in debug.
+//#![cfg(not(debug_assertions))] // Tests are too slow in debug.
 #![cfg(test)]
 
 use crate::{
@@ -429,13 +429,13 @@ impl TestRig {
         }
     }
 
-    pub fn enqueue_blobs_by_range_request(&self, count: u64) {
+    pub fn enqueue_blobs_by_range_request(&self, start_slot: u64, count: u64) {
         self.network_beacon_processor
             .send_blobs_by_range_request(
                 PeerId::random(),
                 InboundRequestId::new_unchecked(42, 24),
                 BlobsByRangeRequest {
-                    start_slot: 0,
+                    start_slot,
                     count,
                 },
             )
@@ -1216,9 +1216,55 @@ async fn test_blobs_by_range() {
     if test_spec::<E>().deneb_fork_epoch.is_none() {
         return;
     };
+    let rig_slot = 64;
+    let mut rig = TestRig::new(rig_slot).await;
+    let slot_count = 32;
+    // can I use slots_per_epoch from types::EthSpec?
+    rig.enqueue_blobs_by_range_request(0, slot_count);
+
+    let mut blob_count = 0;
+    for slot in 0..slot_count {
+        let root = rig
+            .chain
+            .block_root_at_slot(Slot::new(slot), WhenSlotSkipped::None)
+            .unwrap();
+        blob_count += root
+            .map(|root| {
+                rig.chain
+                    .get_blobs(&root)
+                    .map(|list| list.len())
+                    .unwrap_or(0)
+            })
+            .unwrap_or(0);
+    }
+    let mut actual_count = 0;
+    while let Some(next) = rig._network_rx.recv().await {
+        if let NetworkMessage::SendResponse {
+            peer_id: _,
+            response: Response::BlobsByRange(blob),
+            inbound_request_id: _,
+        } = next
+        {
+            if blob.is_some() {
+                actual_count += 1;
+            } else {
+                break;
+            }
+        } else {
+            panic!("unexpected message {:?}", next);
+        }
+    }
+    assert_eq!(blob_count, actual_count);
+}
+
+#[tokio::test]
+async fn test_blobs_by_range_fulu() {
+    if !test_spec::<E>().is_peer_das_scheduled() {
+        return;
+    };
     let mut rig = TestRig::new(64).await;
     let slot_count = 32;
-    rig.enqueue_blobs_by_range_request(slot_count);
+    rig.enqueue_blobs_by_range_request(0, slot_count);
 
     let mut blob_count = 0;
     for slot in 0..slot_count {
@@ -1252,5 +1298,7 @@ async fn test_blobs_by_range() {
             panic!("unexpected message {:?}", next);
         }
     }
+    assert_eq!(blob_count, 0);
+    assert_eq!(actual_count, 0);
     assert_eq!(blob_count, actual_count);
 }