Implement EIP-7892 BPO hardforks

beacon_node/beacon_chain/src/test_utils.rs

@@ -516,11 +516,7 @@ where
         self
     }
 
-    pub fn mock_execution_layer(self) -> Self {
-        self.mock_execution_layer_with_config()
-    }
-
-    pub fn mock_execution_layer_with_config(mut self) -> Self {
+    pub fn mock_execution_layer(mut self) -> Self {
         let mock = mock_execution_layer_from_parts::<E>(
             self.spec.clone().expect("cannot build without spec"),
             self.runtime.task_executor.clone(),

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -142,6 +142,7 @@ pub struct ExecutionBlockGenerator<E: EthSpec> {
     pub pending_payloads: HashMap<ExecutionBlockHash, ExecutionPayload<E>>,
     pub next_payload_id: u64,
     pub payload_ids: HashMap<PayloadId, ExecutionPayload<E>>,
+    min_blobs_count: usize,
     /*
      * Post-merge fork triggers
      */
@@ -188,6 +189,7 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
             pending_payloads: <_>::default(),
             next_payload_id: 0,
             payload_ids: <_>::default(),
+            min_blobs_count: 0,
             shanghai_time,
             cancun_time,
             prague_time,
@@ -318,6 +320,10 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         Ok(())
     }
 
+    pub fn set_min_blob_count(&mut self, count: usize) {
+        self.min_blobs_count = count;
+    }
+
     pub fn insert_pow_block(&mut self, block_number: u64) -> Result<(), String> {
         if let Some(finalized_block_hash) = self.finalized_block_hash {
             return Err(format!(
@@ -702,8 +708,10 @@ 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;
-            let num_blobs = rng.gen::<usize>() % (max_blobs + 1);
+            // 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_range(self.min_blobs_count..=max_blobs);
             let (bundle, transactions) = generate_blobs(num_blobs, fork_name)?;
             for tx in Vec::from(transactions) {
                 execution_payload

beacon_node/http_api/tests/tests.rs

@@ -138,7 +138,7 @@ impl ApiTester {
             .deterministic_keypairs(VALIDATOR_COUNT)
             .deterministic_withdrawal_keypairs(VALIDATOR_COUNT)
             .fresh_ephemeral_store()
-            .mock_execution_layer_with_config()
+            .mock_execution_layer()
             .build();
 
         harness

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>(),

beacon_node/network/src/network_beacon_processor/tests.rs

@@ -37,8 +37,8 @@ use tokio::sync::mpsc;
 use types::blob_sidecar::FixedBlobSidecarList;
 use types::{
     Attestation, AttesterSlashing, BlobSidecar, BlobSidecarList, ChainSpec, DataColumnSidecarList,
-    DataColumnSubnetId, Epoch, EthSpec, ForkName, Hash256, MainnetEthSpec, ProposerSlashing,
-    SignedAggregateAndProof, SignedBeaconBlock, SignedVoluntaryExit, Slot, SubnetId,
+    DataColumnSubnetId, Epoch, Hash256, MainnetEthSpec, ProposerSlashing, SignedAggregateAndProof,
+    SignedBeaconBlock, SignedVoluntaryExit, Slot, SubnetId,
 };
 
 type E = MainnetEthSpec;
@@ -129,6 +129,14 @@ impl TestRig {
             "precondition: current slot is one after head"
         );
 
+        // Ensure there is a blob in the next block. Required for some tests.
+        harness
+            .mock_execution_layer
+            .as_ref()
+            .unwrap()
+            .server
+            .execution_block_generator()
+            .set_min_blob_count(1);
         let (next_block_tuple, next_state) = harness
             .make_block(head.beacon_state.clone(), harness.chain.slot().unwrap())
             .await;
@@ -799,9 +807,11 @@ async fn import_gossip_block_unacceptably_early() {
 /// Data columns that have already been processed but unobserved should be propagated without re-importing.
 #[tokio::test]
 async fn accept_processed_gossip_data_columns_without_import() {
-    let processor_config = BeaconProcessorConfig::default();
-    let fulu_genesis_spec = ForkName::Fulu.make_genesis_spec(E::default_spec());
-    let mut rig = TestRig::new_parametric(SMALL_CHAIN, processor_config, fulu_genesis_spec).await;
+    if test_spec::<E>().fulu_fork_epoch.is_none() {
+        return;
+    };
+
+    let mut rig = TestRig::new(SMALL_CHAIN).await;
 
     // GIVEN the data columns have already been processed but unobserved.
     // 1. verify data column with `DoNotObserve` to create verified but unobserved data columns.

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))