From 5a42f6b067e144d5913a476ac80d59111823d7c8 Mon Sep 17 00:00:00 2001
From: realbigsean <sean@sigmaprime.io>
Date: Wed, 7 Dec 2022 15:35:46 -0500
Subject: [PATCH] range block or block+blob requests

---
 beacon_node/beacon_chain/src/beacon_chain.rs  | 20 +++++++------
 .../network/src/sync/network_context.rs       | 28 ++++++++++++++-----
 2 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index c50f19267..0c053b14e 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/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.epoch().ok().map(|current_epoch|{
-                std::cmp::max(
-                    fork_epoch,
-                    current_epoch - *MIN_EPOCHS_FOR_BLOBS_SIDECARS_REQUESTS,
-                )
+        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))
diff --git a/beacon_node/network/src/sync/network_context.rs b/beacon_node/network/src/sync/network_context.rs
index 7680597e4..94801aa87 100644
--- a/beacon_node/network/src/sync/network_context.rs
+++ b/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.
-            ExpectedBatchTy::OnlyBlockBlobs
+
+            if let Some(data_availability_boundary) = self.chain.data_availability_boundary() {
+                if epoch >= data_availability_boundary {
+                    ExpectedBatchTy::OnlyBlockBlobs
+                } else {
+                    ExpectedBatchTy::OnlyBlock
+                }
+            } else {
+                ExpectedBatchTy::OnlyBlock
+            }
         }
     }
 }