Implement EIP-7892 BPO hardforks

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -702,7 +702,9 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         if fork_name.deneb_enabled() {
             // get random number between 0 and Max Blobs
             let mut rng = self.rng.lock();
-            let max_blobs = self.spec.max_blobs_per_block_by_fork(fork_name) as usize;
+            // TODO(EIP-7892): see FIXME below
+            // FIXME: this will break with BPO forks. This function needs to calculate the epoch based on block timestamp..
+            let max_blobs = self.spec.max_blobs_per_block_within_fork(fork_name) as usize;
             let num_blobs = rng.gen::<usize>() % (max_blobs + 1);
             let (bundle, transactions) = generate_blobs(num_blobs, fork_name)?;
             for tx in Vec::from(transactions) {

beacon_node/lighthouse_network/src/rpc/handler.rs

@@ -28,7 +28,7 @@ use std::{
 use tokio::time::{sleep, Sleep};
 use tokio_util::time::{delay_queue, DelayQueue};
 use tracing::{debug, trace};
-use types::{EthSpec, ForkContext};
+use types::{EthSpec, ForkContext, Slot};
 
 /// The number of times to retry an outbound upgrade in the case of IO errors.
 const IO_ERROR_RETRIES: u8 = 3;
@@ -932,9 +932,8 @@ where
                 }
             }
             RequestType::BlobsByRange(request) => {
-                let max_requested_blobs = request
-                    .count
-                    .saturating_mul(spec.max_blobs_per_block_by_fork(current_fork));
+                let epoch = Slot::new(request.start_slot).epoch(E::slots_per_epoch());
+                let max_requested_blobs = request.max_blobs_requested(epoch, spec);
                 let max_allowed = spec.max_request_blob_sidecars(current_fork) as u64;
                 if max_requested_blobs > max_allowed {
                     self.events_out.push(HandlerEvent::Err(HandlerErr::Inbound {

beacon_node/lighthouse_network/src/rpc/methods.rs

@@ -16,11 +16,10 @@ use types::blob_sidecar::BlobIdentifier;
 use types::light_client_update::MAX_REQUEST_LIGHT_CLIENT_UPDATES;
 use types::{
     blob_sidecar::BlobSidecar, ChainSpec, ColumnIndex, DataColumnSidecar,
-    DataColumnsByRootIdentifier, Epoch, EthSpec, Hash256, LightClientBootstrap,
+    DataColumnsByRootIdentifier, Epoch, EthSpec, ForkContext, Hash256, LightClientBootstrap,
     LightClientFinalityUpdate, LightClientOptimisticUpdate, LightClientUpdate, RuntimeVariableList,
     SignedBeaconBlock, Slot,
 };
-use types::{ForkContext, ForkName};
 
 /// Maximum length of error message.
 pub type MaxErrorLen = U256;
@@ -328,8 +327,8 @@ pub struct BlobsByRangeRequest {
 }
 
 impl BlobsByRangeRequest {
-    pub fn max_blobs_requested(&self, current_fork: ForkName, spec: &ChainSpec) -> u64 {
-        let max_blobs_per_block = spec.max_blobs_per_block_by_fork(current_fork);
+    pub fn max_blobs_requested(&self, epoch: Epoch, spec: &ChainSpec) -> u64 {
+        let max_blobs_per_block = spec.max_blobs_per_block(epoch);
         self.count.saturating_mul(max_blobs_per_block)
     }
 }

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -21,7 +21,7 @@ use types::{
     EmptyBlock, EthSpec, EthSpecId, ForkContext, ForkName, LightClientBootstrap,
     LightClientBootstrapAltair, LightClientFinalityUpdate, LightClientFinalityUpdateAltair,
     LightClientOptimisticUpdate, LightClientOptimisticUpdateAltair, LightClientUpdate,
-    MainnetEthSpec, MinimalEthSpec, Signature, SignedBeaconBlock,
+    MainnetEthSpec, MinimalEthSpec, Signature, SignedBeaconBlock, Slot,
 };
 
 // Note: Hardcoding the `EthSpec` type for `SignedBeaconBlock` as min/max values is
@@ -633,7 +633,8 @@ pub fn rpc_blob_limits<E: EthSpec>() -> RpcLimits {
 pub fn rpc_data_column_limits<E: EthSpec>(fork_name: ForkName, spec: &ChainSpec) -> RpcLimits {
     RpcLimits::new(
         DataColumnSidecar::<E>::min_size(),
-        DataColumnSidecar::<E>::max_size(spec.max_blobs_per_block_by_fork(fork_name) as usize),
+        // TODO(EIP-7892): fix this once we change fork-version on BPO forks
+        DataColumnSidecar::<E>::max_size(spec.max_blobs_per_block_within_fork(fork_name) as usize),
     )
 }
 
@@ -732,13 +733,16 @@ impl<E: EthSpec> RequestType<E> {
     /* These functions are used in the handler for stream management */
 
     /// Maximum number of responses expected for this request.
-    pub fn max_responses(&self, current_fork: ForkName, spec: &ChainSpec) -> u64 {
+    /// TODO(EIP-7892): refactor this to remove `_current_fork`
+    pub fn max_responses(&self, _current_fork: ForkName, spec: &ChainSpec) -> u64 {
         match self {
             RequestType::Status(_) => 1,
             RequestType::Goodbye(_) => 0,
             RequestType::BlocksByRange(req) => *req.count(),
             RequestType::BlocksByRoot(req) => req.block_roots().len() as u64,
-            RequestType::BlobsByRange(req) => req.max_blobs_requested(current_fork, spec),
+            RequestType::BlobsByRange(req) => {
+                req.max_blobs_requested(Slot::new(req.start_slot).epoch(E::slots_per_epoch()), spec)
+            }
             RequestType::BlobsByRoot(req) => req.blob_ids.len() as u64,
             RequestType::DataColumnsByRoot(req) => req.max_requested() as u64,
             RequestType::DataColumnsByRange(req) => req.max_requested::<E>(),

common/eth2/src/lib.rs

@@ -1296,7 +1296,9 @@ impl BeaconNodeHttpClient {
         }
 
         self.get_fork_contextual(path, |fork| {
-            (fork, spec.max_blobs_per_block_by_fork(fork) as usize)
+            // TODO(EIP-7892): this will overestimate the max number of blobs
+            // It would be better if we could get an epoch passed into this function
+            (fork, spec.max_blobs_per_block_within_fork(fork) as usize)
         })
         .await
         .map(|opt| opt.map(BeaconResponse::ForkVersioned))