range block or block+blob requests

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -5422,21 +5422,25 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     /// The epoch at which we require a data availability check in block processing.
     /// `None` if the `Eip4844` fork is disabled.
     pub fn data_availability_boundary(&self) -> Option<Epoch> {
-        self.spec.eip4844_fork_epoch.map(|fork_epoch| {
+        self.spec
+            .eip4844_fork_epoch
+            .map(|fork_epoch| {
                 self.epoch().ok().map(|current_epoch| {
                     std::cmp::max(
                         fork_epoch,
                         current_epoch - *MIN_EPOCHS_FOR_BLOBS_SIDECARS_REQUESTS,
                     )
                 })
-        }).flatten()
+            })
+            .flatten()
     }
 
     /// Returns `true` if we are at or past the `Eip4844` fork. This will always return `false` if
     /// the `Eip4844` fork is disabled.
     pub fn is_data_availability_check_required(&self) -> Result<bool, Error> {
         let current_epoch = self.epoch()?;
-        Ok(self.spec
+        Ok(self
+            .spec
             .eip4844_fork_epoch
             .map(|fork_epoch| fork_epoch <= current_epoch)
             .unwrap_or(false))

beacon_node/network/src/sync/network_context.rs

@@ -466,7 +466,11 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         peer_id: PeerId,
         request: BlocksByRootRequest,
     ) -> Result<Id, &'static str> {
-        let request = if self.chain.is_data_availability_check_required().map_err(|_|"Unable to read slot clock")?  {
+        let request = if self
+            .chain
+            .is_data_availability_check_required()
+            .map_err(|_| "Unable to read slot clock")?
+        {
             trace!(
                 self.log,
                 "Sending BlobsByRoot Request";
@@ -501,7 +505,11 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
         peer_id: PeerId,
         request: BlocksByRootRequest,
     ) -> Result<Id, &'static str> {
-        let request = if self.chain.is_data_availability_check_required().map_err(|_|"Unable to read slot clock")? {
+        let request = if self
+            .chain
+            .is_data_availability_check_required()
+            .map_err(|_| "Unable to read slot clock")?
+        {
             trace!(
                 self.log,
                 "Sending BlobsByRoot Request";
@@ -613,15 +621,21 @@ impl<T: BeaconChainTypes> SyncNetworkContext<T> {
                 EPOCHS_PER_BATCH, 1,
                 "If this is not one, everything will fail horribly"
             );
-            warn!(
-            self.log,
-            "Missing fork boundary and prunning boundary comparison to decide request type. EVERYTHING IS A BLOB, BOB."
-        );
+
             // Here we need access to the beacon chain, check the fork boundary, the current epoch, the
             // blob period to serve and check with that if the batch is a blob batch or not.
             // NOTE: This would carelessly assume batch sizes are always 1 epoch, to avoid needing to
             // align with the batch boundary.
+
+            if let Some(data_availability_boundary) = self.chain.data_availability_boundary() {
+                if epoch >= data_availability_boundary {
                     ExpectedBatchTy::OnlyBlockBlobs
+                } else {
+                    ExpectedBatchTy::OnlyBlock
+                }
+            } else {
+                ExpectedBatchTy::OnlyBlock
+            }
         }
     }
 }