Reduce number of blobs used in tests to speed up CI

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -1277,7 +1277,7 @@ mod pending_components_tests {
         let mut rng = StdRng::seed_from_u64(0xDEADBEEF0BAD5EEDu64);
         let spec = test_spec::<E>();
         let (block, blobs_vec) =
-            generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Random, &mut rng, &spec);
+            generate_rand_block_and_blobs::<E>(ForkName::Deneb, NumBlobs::Random, &mut rng);
         let max_len = spec.max_blobs_per_block(block.epoch()) as usize;
         let mut blobs: RuntimeFixedVector<Option<Arc<BlobSidecar<E>>>> =
             RuntimeFixedVector::default(max_len);

beacon_node/beacon_chain/src/kzg_utils.rs

@@ -463,7 +463,7 @@ mod test {
 
     #[track_caller]
     fn test_validate_data_columns(kzg: &Kzg, spec: &ChainSpec) {
-        let num_of_blobs = 6;
+        let num_of_blobs = 2;
         let (signed_block, blobs, proofs) =
             create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
         let blob_refs = blobs.iter().collect::<Vec<_>>();
@@ -489,7 +489,8 @@ mod test {
 
     #[track_caller]
     fn test_build_data_columns(kzg: &Kzg, spec: &ChainSpec) {
-        let num_of_blobs = 6;
+        // Using at least 2 blobs to make sure we're arranging the data columns correctly.
+        let num_of_blobs = 2;
         let (signed_block, blobs, proofs) =
             create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
 
@@ -529,6 +530,7 @@ mod test {
 
     #[track_caller]
     fn test_reconstruct_data_columns(kzg: &Kzg, spec: &ChainSpec) {
+        // Using at least 2 blobs to make sure we're arranging the data columns correctly.
         let num_of_blobs = 2;
         let (signed_block, blobs, proofs) =
             create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
@@ -552,6 +554,7 @@ mod test {
 
     #[track_caller]
     fn test_reconstruct_data_columns_unordered(kzg: &Kzg, spec: &ChainSpec) {
+        // Using at least 2 blobs to make sure we're arranging the data columns correctly.
         let num_of_blobs = 2;
         let (signed_block, blobs, proofs) =
             create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
@@ -573,7 +576,7 @@ mod test {
 
     #[track_caller]
     fn test_reconstruct_blobs_from_data_columns(kzg: &Kzg, spec: &ChainSpec) {
-        let num_of_blobs = 6;
+        let num_of_blobs = 3;
         let (signed_block, blobs, proofs) =
             create_test_fulu_block_and_blobs::<E>(num_of_blobs, spec);
         let blob_refs = blobs.iter().collect::<Vec<_>>();
@@ -583,7 +586,8 @@ mod test {
 
         // Now reconstruct
         let signed_blinded_block = signed_block.into();
-        let blob_indices = vec![3, 4, 5];
+        // Using at least 2 blobs to make sure we're arranging the data columns correctly.
+        let blob_indices = vec![1, 2];
         let reconstructed_blobs = reconstruct_blobs(
             kzg,
             &column_sidecars.iter().as_slice()[0..column_sidecars.len() / 2],

beacon_node/beacon_chain/src/test_utils.rs

@@ -3244,96 +3244,49 @@ pub enum NumBlobs {
     None,
 }
 
+macro_rules! add_blob_transactions {
+    ($message:expr, $payload_type:ty, $num_blobs:expr, $rng:expr, $fork_name:expr) => {{
+        let num_blobs = match $num_blobs {
+            NumBlobs::Random => $rng.random_range(1..=2),
+            NumBlobs::Number(n) => n,
+            NumBlobs::None => 0,
+        };
+        let (bundle, transactions) =
+            execution_layer::test_utils::generate_blobs::<E>(num_blobs, $fork_name).unwrap();
+
+        let payload: &mut $payload_type = &mut $message.body.execution_payload;
+        payload.execution_payload.transactions = <_>::default();
+        for tx in Vec::from(transactions) {
+            payload.execution_payload.transactions.push(tx).unwrap();
+        }
+        $message.body.blob_kzg_commitments = bundle.commitments.clone();
+        bundle
+    }};
+}
+
 pub fn generate_rand_block_and_blobs<E: EthSpec>(
     fork_name: ForkName,
     num_blobs: NumBlobs,
     rng: &mut impl Rng,
-    spec: &ChainSpec,
 ) -> (SignedBeaconBlock<E, FullPayload<E>>, Vec<BlobSidecar<E>>) {
     let inner = map_fork_name!(fork_name, BeaconBlock, <_>::random_for_test(rng));
 
     let mut block = SignedBeaconBlock::from_block(inner, types::Signature::random_for_test(rng));
-    let max_blobs = spec.max_blobs_per_block(block.epoch()) as usize;
     let mut blob_sidecars = vec![];
 
     let bundle = match block {
         SignedBeaconBlock::Deneb(SignedBeaconBlockDeneb {
             ref mut message, ..
-        }) => {
-            // Get either zero blobs or a random number of blobs between 1 and Max Blobs.
-            let payload: &mut FullPayloadDeneb<E> = &mut message.body.execution_payload;
-            let num_blobs = match num_blobs {
-                NumBlobs::Random => rng.random_range(1..=max_blobs),
-                NumBlobs::Number(n) => n,
-                NumBlobs::None => 0,
-            };
-            let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
-
-            payload.execution_payload.transactions = <_>::default();
-            for tx in Vec::from(transactions) {
-                payload.execution_payload.transactions.push(tx).unwrap();
-            }
-            message.body.blob_kzg_commitments = bundle.commitments.clone();
-            bundle
-        }
+        }) => add_blob_transactions!(message, FullPayloadDeneb<E>, num_blobs, rng, fork_name),
         SignedBeaconBlock::Electra(SignedBeaconBlockElectra {
             ref mut message, ..
-        }) => {
-            // Get either zero blobs or a random number of blobs between 1 and Max Blobs.
-            let payload: &mut FullPayloadElectra<E> = &mut message.body.execution_payload;
-            let num_blobs = match num_blobs {
-                NumBlobs::Random => rng.random_range(1..=max_blobs),
-                NumBlobs::Number(n) => n,
-                NumBlobs::None => 0,
-            };
-            let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
-            payload.execution_payload.transactions = <_>::default();
-            for tx in Vec::from(transactions) {
-                payload.execution_payload.transactions.push(tx).unwrap();
-            }
-            message.body.blob_kzg_commitments = bundle.commitments.clone();
-            bundle
-        }
+        }) => add_blob_transactions!(message, FullPayloadElectra<E>, num_blobs, rng, fork_name),
         SignedBeaconBlock::Fulu(SignedBeaconBlockFulu {
             ref mut message, ..
-        }) => {
-            // Get either zero blobs or a random number of blobs between 1 and Max Blobs.
-            let payload: &mut FullPayloadFulu<E> = &mut message.body.execution_payload;
-            let num_blobs = match num_blobs {
-                NumBlobs::Random => rng.random_range(1..=max_blobs),
-                NumBlobs::Number(n) => n,
-                NumBlobs::None => 0,
-            };
-            let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
-            payload.execution_payload.transactions = <_>::default();
-            for tx in Vec::from(transactions) {
-                payload.execution_payload.transactions.push(tx).unwrap();
-            }
-            message.body.blob_kzg_commitments = bundle.commitments.clone();
-            bundle
-        }
+        }) => add_blob_transactions!(message, FullPayloadFulu<E>, num_blobs, rng, fork_name),
         SignedBeaconBlock::Gloas(SignedBeaconBlockGloas {
             ref mut message, ..
-        }) => {
-            // Get either zero blobs or a random number of blobs between 1 and Max Blobs.
-            let payload: &mut FullPayloadGloas<E> = &mut message.body.execution_payload;
-            let num_blobs = match num_blobs {
-                NumBlobs::Random => rng.random_range(1..=max_blobs),
-                NumBlobs::Number(n) => n,
-                NumBlobs::None => 0,
-            };
-            let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
-            payload.execution_payload.transactions = <_>::default();
-            for tx in Vec::from(transactions) {
-                payload.execution_payload.transactions.push(tx).unwrap();
-            }
-            message.body.blob_kzg_commitments = bundle.commitments.clone();
-            bundle
-        }
+        }) => add_blob_transactions!(message, FullPayloadGloas<E>, num_blobs, rng, fork_name),
         _ => return (block, blob_sidecars),
     };
 
@@ -3374,7 +3327,7 @@ pub fn generate_rand_block_and_data_columns<E: EthSpec>(
     SignedBeaconBlock<E, FullPayload<E>>,
     DataColumnSidecarList<E>,
 ) {
-    let (block, _blobs) = generate_rand_block_and_blobs(fork_name, num_blobs, rng, spec);
+    let (block, _blobs) = generate_rand_block_and_blobs(fork_name, num_blobs, rng);
     let data_columns = generate_data_column_sidecars_from_block(&block, spec);
     (block, data_columns)
 }

beacon_node/execution_layer/src/engine_api/http.rs

@@ -1453,8 +1453,7 @@ mod test {
 
     impl Tester {
         pub fn new(with_auth: bool) -> Self {
-            let spec = Arc::new(MainnetEthSpec::default_spec());
-            let server = MockServer::unit_testing(spec);
+            let server = MockServer::unit_testing();
 
             let rpc_url = SensitiveUrl::parse(&server.url()).unwrap();
             let echo_url = SensitiveUrl::parse(&format!("{}/echo", server.url())).unwrap();

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -13,6 +13,7 @@ use rand::{Rng, SeedableRng, rngs::StdRng};
 use serde::{Deserialize, Serialize};
 use ssz::Decode;
 use ssz_types::VariableList;
+use std::cmp::max;
 use std::collections::HashMap;
 use std::sync::Arc;
 use tree_hash::TreeHash;
@@ -157,7 +158,6 @@ pub struct ExecutionBlockGenerator<E: EthSpec> {
     pub blobs_bundles: HashMap<PayloadId, BlobsBundle<E>>,
     pub kzg: Option<Arc<Kzg>>,
     rng: Arc<Mutex<StdRng>>,
-    spec: Arc<ChainSpec>,
 }
 
 fn make_rng() -> Arc<Mutex<StdRng>> {
@@ -177,7 +177,6 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
         prague_time: Option<u64>,
         osaka_time: Option<u64>,
         amsterdam_time: Option<u64>,
-        spec: Arc<ChainSpec>,
         kzg: Option<Arc<Kzg>>,
     ) -> Self {
         let mut generator = Self {
@@ -200,7 +199,6 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
             blobs_bundles: <_>::default(),
             kzg,
             rng: make_rng(),
-            spec,
         };
 
         generator.insert_pow_block(0).unwrap();
@@ -732,11 +730,10 @@ impl<E: EthSpec> ExecutionBlockGenerator<E> {
 
         let fork_name = execution_payload.fork_name();
         if fork_name.deneb_enabled() {
-            // get random number between 0 and Max Blobs
+            // get random number between 0 and 1 blobs by default
+            // For tests that need higher blob count, consider adding a `set_max_blob_count` method
             let mut rng = self.rng.lock();
-            // 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 max_blobs = max(1, self.min_blobs_count);
             let num_blobs = rng.random_range(self.min_blobs_count..=max_blobs);
             let (bundle, transactions) = generate_blobs(num_blobs, fork_name)?;
             for tx in Vec::from(transactions) {
@@ -977,7 +974,6 @@ mod test {
         const TERMINAL_DIFFICULTY: u64 = 10;
         const TERMINAL_BLOCK: u64 = 10;
         const DIFFICULTY_INCREMENT: u64 = 1;
-        let spec = Arc::new(MainnetEthSpec::default_spec());
 
         let mut generator: ExecutionBlockGenerator<MainnetEthSpec> = ExecutionBlockGenerator::new(
             Uint256::from(TERMINAL_DIFFICULTY),
@@ -988,7 +984,6 @@ mod test {
             None,
             None,
             None,
-            spec,
             None,
         );
 

beacon_node/execution_layer/src/test_utils/mock_execution_layer.rs

@@ -63,7 +63,6 @@ impl<E: EthSpec> MockExecutionLayer<E> {
             prague_time,
             osaka_time,
             amsterdam_time,
-            spec.clone(),
             kzg,
         );
 

beacon_node/execution_layer/src/test_utils/mod.rs

@@ -22,7 +22,7 @@ use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::sync::{Arc, LazyLock};
 use tokio::{runtime, sync::oneshot};
 use tracing::info;
-use types::{ChainSpec, EthSpec, ExecutionBlockHash, Uint256};
+use types::{EthSpec, ExecutionBlockHash, Uint256};
 use warp::{Filter, Rejection, http::StatusCode};
 
 use crate::EngineCapabilities;
@@ -114,7 +114,7 @@ pub struct MockServer<E: EthSpec> {
 }
 
 impl<E: EthSpec> MockServer<E> {
-    pub fn unit_testing(chain_spec: Arc<ChainSpec>) -> Self {
+    pub fn unit_testing() -> Self {
         Self::new(
             &runtime::Handle::current(),
             JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap(),
@@ -126,15 +126,13 @@ impl<E: EthSpec> MockServer<E> {
             None, // FIXME(electra): should this be the default?
             None, // FIXME(fulu): should this be the default?
             None, // FIXME(gloas): should this be the default?
-            chain_spec,
             None,
         )
     }
 
     pub fn new_with_config(
         handle: &runtime::Handle,
         config: MockExecutionConfig,
-        spec: Arc<ChainSpec>,
         kzg: Option<Arc<Kzg>>,
     ) -> Self {
         create_test_tracing_subscriber();
@@ -161,7 +159,6 @@ impl<E: EthSpec> MockServer<E> {
             prague_time,
             osaka_time,
             amsterdam_time,
-            spec,
             kzg,
         );
 
@@ -226,7 +223,6 @@ impl<E: EthSpec> MockServer<E> {
         prague_time: Option<u64>,
         osaka_time: Option<u64>,
         amsterdam_time: Option<u64>,
-        spec: Arc<ChainSpec>,
         kzg: Option<Arc<Kzg>>,
     ) -> Self {
         Self::new_with_config(
@@ -243,7 +239,6 @@ impl<E: EthSpec> MockServer<E> {
                 osaka_time,
                 amsterdam_time,
             },
-            spec,
             kzg,
         )
     }

beacon_node/http_api/tests/broadcast_validation_tests.rs

@@ -822,6 +822,14 @@ pub async fn blinded_gossip_invalid() {
 
     tester.harness.advance_slot();
 
+    // Ensure there's at least one blob in the block, so we don't run into failures when the
+    // block generator logic changes, as different errors could be returned:
+    // * Invalidity of blocks: `NotFinalizedDescendant`
+    // * Invalidity of blobs: `ParentUnknown`
+    tester
+        .harness
+        .execution_block_generator()
+        .set_min_blob_count(1);
     let (blinded_block, _) = tester
         .harness
         .make_blinded_block_with_modifier(chain_state_before, slot, |b| {
@@ -837,21 +845,20 @@ pub async fn blinded_gossip_invalid() {
     assert!(response.is_err());
 
     let error_response: eth2::Error = response.err().unwrap();
+    assert_eq!(error_response.status(), Some(StatusCode::BAD_REQUEST));
+
     let pre_finalized_block_root = Hash256::zero();
-    /* mandated by Beacon API spec */
-    if tester.harness.spec.is_fulu_scheduled() {
-        // XXX: this should be a 400 but is a 500 due to the mock-builder being janky
-        assert_eq!(
-            error_response.status(),
-            Some(StatusCode::INTERNAL_SERVER_ERROR)
-        );
+    let expected_error_msg = if tester.harness.spec.is_fulu_scheduled() {
+        format!(
+            "BAD_REQUEST: NotFinalizedDescendant {{ block_parent_root: {pre_finalized_block_root:?} }}"
+        )
     } else {
-        assert_eq!(error_response.status(), Some(StatusCode::BAD_REQUEST));
-        assert_server_message_error(
-            error_response,
-            format!("BAD_REQUEST: ParentUnknown {{ parent_root: {pre_finalized_block_root:?} }}"),
-        );
-    }
+        // Since Deneb, the invalidity of the blobs will be detected prior to the invalidity of the
+        // block.
+        format!("BAD_REQUEST: ParentUnknown {{ parent_root: {pre_finalized_block_root:?} }}")
+    };
+
+    assert_server_message_error(error_response, expected_error_msg);
 }
 
 /// Process a blinded block that is invalid, but valid on gossip.
@@ -1647,6 +1654,10 @@ pub async fn block_seen_on_gossip_with_some_blobs_or_columns() {
         )
         .await;
     tester.harness.advance_slot();
+    tester
+        .harness
+        .execution_block_generator()
+        .set_min_blob_count(2);
 
     let slot_a = Slot::new(num_initial);
     let slot_b = slot_a + 1;