Use valid sidecars in SSE tests

michaelsproul · michaelsproul · commit 0cfde282dfce · 2025-10-21T17:15:47.000+11:00
diff --git a/beacon_node/beacon_chain/tests/events.rs b/beacon_node/beacon_chain/tests/events.rs
@@ -1,15 +1,13 @@
 use beacon_chain::blob_verification::GossipVerifiedBlob;
 use beacon_chain::data_column_verification::GossipVerifiedDataColumn;
-use beacon_chain::test_utils::{BeaconChainHarness, TEST_DATA_COLUMN_SIDECARS_SSZ};
+use beacon_chain::test_utils::{BeaconChainHarness, generate_data_column_sidecars_from_block};
 use eth2::types::{EventKind, SseBlobSidecar, SseDataColumnSidecar};
 use rand::SeedableRng;
 use rand::rngs::StdRng;
 use std::sync::Arc;
 use types::blob_sidecar::FixedBlobSidecarList;
 use types::test_utils::TestRandom;
-use types::{
-    BlobSidecar, DataColumnSidecar, EthSpec, ForkName, MinimalEthSpec, RuntimeVariableList, Slot,
-};
+use types::{BlobSidecar, DataColumnSidecar, EthSpec, ForkName, MinimalEthSpec, Slot};
 
 type E = MinimalEthSpec;
 
@@ -108,19 +106,18 @@ async fn blob_sidecar_event_on_process_rpc_blobs() {
     let mut blob_event_receiver = event_handler.subscribe_blob_sidecar();
 
     // build and process multiple rpc blobs
-    let kzg = harness.chain.kzg.as_ref();
-    let mut rng = StdRng::seed_from_u64(0xDEADBEEF0BAD5EEDu64);
+    harness.execution_block_generator().set_min_blob_count(2);
 
-    let mut blob_1 = BlobSidecar::random_valid(&mut rng, kzg).unwrap();
-    let mut blob_2 = BlobSidecar {
-        index: 1,
-        ..BlobSidecar::random_valid(&mut rng, kzg).unwrap()
-    };
-    let parent_root = harness.chain.head().head_block_root();
-    blob_1.signed_block_header.message.parent_root = parent_root;
-    blob_2.signed_block_header.message.parent_root = parent_root;
-    let blob_1 = Arc::new(blob_1);
-    let blob_2 = Arc::new(blob_2);
+    let head_state = harness.get_current_state();
+    let slot = head_state.slot() + 1;
+    let ((signed_block, opt_blobs), _) = harness.make_block(head_state, slot).await;
+    let (kzg_proofs, blobs) = opt_blobs.unwrap();
+    assert!(blobs.len() > 2);
+
+    let blob_1 =
+        Arc::new(BlobSidecar::new(0, blobs[0].clone(), &signed_block, kzg_proofs[0]).unwrap());
+    let blob_2 =
+        Arc::new(BlobSidecar::new(1, blobs[1].clone(), &signed_block, kzg_proofs[1]).unwrap());
 
     let blobs = FixedBlobSidecarList::new(vec![Some(blob_1.clone()), Some(blob_2.clone())]);
     let expected_sse_blobs = vec![
@@ -130,7 +127,7 @@ async fn blob_sidecar_event_on_process_rpc_blobs() {
 
     let _ = harness
         .chain
-        .process_rpc_blobs(blob_1.slot(), blob_1.block_root(), blobs)
+        .process_rpc_blobs(slot, blob_1.block_root(), blobs)
         .await
         .unwrap();
 
@@ -159,20 +156,24 @@ async fn data_column_sidecar_event_on_process_rpc_columns() {
     let event_handler = harness.chain.event_handler.as_ref().unwrap();
     let mut data_column_event_receiver = event_handler.subscribe_data_column_sidecar();
 
+    // build a valid block
+    harness.execution_block_generator().set_min_blob_count(1);
+
+    let head_state = harness.get_current_state();
+    let slot = head_state.slot() + 1;
+    let ((signed_block, opt_blobs), _) = harness.make_block(head_state, slot).await;
+    let (_, blobs) = opt_blobs.unwrap();
+    assert!(!blobs.is_empty());
+
     // load the precomputed column sidecar to avoid computing them for every block in the tests.
-    let mut sidecar = RuntimeVariableList::<DataColumnSidecar<E>>::from_ssz_bytes(
-        TEST_DATA_COLUMN_SIDECARS_SSZ,
-        E::number_of_columns(),
-    )
-    .unwrap()[0]
-        .clone();
-    let parent_root = harness.chain.head().head_block_root();
-    sidecar.signed_block_header.message.parent_root = parent_root;
+    let data_column_sidecars =
+        generate_data_column_sidecars_from_block(&signed_block, &harness.chain.spec);
+    let sidecar = data_column_sidecars[0].clone();
     let expected_sse_data_column = SseDataColumnSidecar::from_data_column_sidecar(&sidecar);
 
     let _ = harness
         .chain
-        .process_rpc_custody_columns(vec![Arc::new(sidecar)])
+        .process_rpc_custody_columns(vec![sidecar])
         .await
         .unwrap();
 
