Move ERA test vectors to external repo, download at test time

Test vectors are now hosted at dapplion/era-test-vectors and downloaded
via Makefile (same pattern as slashing_protection interchange tests).

beacon_node/beacon_chain/src/era/tests.rs

@@ -4,17 +4,41 @@
 /// - Electra from genesis, Fulu at epoch 100000
 /// - SLOTS_PER_HISTORICAL_ROOT = 64 (one ERA = 64 slots = 8 epochs)
 /// - 13 ERA files covering 832 slots, 767 blocks, 1024 validators
+///
+/// All subtests run from a single #[test] to avoid nextest download races
+/// (same pattern as slashing_protection/tests/interop.rs).
 use super::consumer::EraFileDir;
 use reth_era::common::file_ops::StreamReader;
+use serde::Deserialize;
 use std::path::PathBuf;
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 use store::{DBColumn, HotColdDB, KeyValueStore, StoreConfig};
-use types::{BeaconState, ChainSpec, Config, EthSpec, Hash256, MinimalEthSpec};
+use types::{BeaconState, ChainSpec, Config, EthSpec, Hash256, MinimalEthSpec, Slot};
 
-fn test_vectors_dir() -> PathBuf {
-    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+#[derive(Deserialize)]
+struct Metadata {
+    head_slot: u64,
+    head_root: String,
+    era_count: u64,
+}
+
+static TEST_VECTORS_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
+    let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .join("tests")
-        .join("era_test_vectors")
+        .join("era_test_vectors");
+    let make_output = std::process::Command::new("make")
+        .current_dir(&dir)
+        .output()
+        .expect("need `make` to download ERA test vectors");
+    if !make_output.status.success() {
+        eprintln!("{}", String::from_utf8_lossy(&make_output.stderr));
+        panic!("Running `make` for ERA test vectors failed, see above");
+    }
+    dir.join("vectors")
+});
+
+fn test_vectors_dir() -> &'static PathBuf {
+    &TEST_VECTORS_DIR
 }
 
 fn load_test_spec() -> ChainSpec {
@@ -27,7 +51,6 @@ fn load_test_spec() -> ChainSpec {
 }
 
 fn load_genesis_state(spec: &ChainSpec) -> BeaconState<MinimalEthSpec> {
-    // Extract genesis state from ERA 0 file
     let era_dir = test_vectors_dir().join("era");
     let era0_path = std::fs::read_dir(&era_dir)
         .expect("read era dir")
@@ -52,7 +75,6 @@ type TestStore = HotColdDB<
     store::MemoryStore<MinimalEthSpec>,
 >;
 
-/// Import all ERA files into a fresh ephemeral store.
 fn import_all_era_files() -> (TestStore, ChainSpec, u64) {
     let spec = load_test_spec();
     let era_dir_path = test_vectors_dir().join("era");
@@ -63,23 +85,13 @@ fn import_all_era_files() -> (TestStore, ChainSpec, u64) {
         .expect("create store");
 
     let mut genesis_state = load_genesis_state(&spec);
-    let root = genesis_state.canonical_root().expect("hash genesis");
-    let mut ops = vec![];
-    store
-        .store_cold_state(&root, &genesis_state, &mut ops)
-        .expect("build ops");
-    store.cold_db.do_atomically(ops).expect("write genesis");
-
-    for era in 1..=max_era {
-        era_dir
-            .import_era_file(&store, era, &spec, None)
-            .unwrap_or_else(|e| panic!("import ERA {era}: {e}"));
-    }
+    era_dir
+        .import_all(&store, &mut genesis_state, &spec)
+        .expect("import all ERA files");
 
     (store, spec, max_era)
 }
 
-/// Create ephemeral store with genesis state only.
 fn empty_store(spec: &ChainSpec) -> TestStore {
     let store =
         HotColdDB::open_ephemeral(StoreConfig::default(), Arc::new(spec.clone())).expect("store");
@@ -93,7 +105,6 @@ fn empty_store(spec: &ChainSpec) -> TestStore {
     store
 }
 
-/// Copy ERA files to temp dir, replacing one with a corrupt version.
 fn era_dir_with_corrupt(corrupt_file: &str, target_pattern: &str) -> tempfile::TempDir {
     let tmp = tempfile::TempDir::new().expect("tmp");
     let src = test_vectors_dir();
@@ -113,104 +124,117 @@ fn era_dir_with_corrupt(corrupt_file: &str, target_pattern: &str) -> tempfile::T
     tmp
 }
 
-// =============================================================================
-// CONSUMER TEST
-// =============================================================================
+fn assert_import_fails(
+    corrupt_file: &str,
+    target_pattern: &str,
+    target_era: u64,
+    expected_err: &str,
+) {
+    let tmp = era_dir_with_corrupt(corrupt_file, target_pattern);
+    let spec = load_test_spec();
+    let era_dir = EraFileDir::new::<MinimalEthSpec>(&tmp.path().join("era"), &spec)
+        .expect("init should succeed");
+    let store = empty_store(&spec);
 
-/// Import all ERA files, verify block hash chain and state roots.
-#[test]
-fn era_consumer_imports_and_verifies() {
-    let (store, spec, max_era) = import_all_era_files();
-    let slots_per_era = MinimalEthSpec::slots_per_historical_root() as u64;
-    let max_slot = max_era * slots_per_era;
-
-    // Collect all blocks by reading block root index, then fetching from store
-    let mut blocks_by_slot = std::collections::BTreeMap::new();
-    let mut seen_roots = std::collections::HashSet::new();
-
-    for slot in 0..max_slot {
-        let key = slot.to_be_bytes().to_vec();
-        if let Some(root_bytes) = store
-            .cold_db
-            .get_bytes(DBColumn::BeaconBlockRoots, &key)
-            .expect("read index")
-        {
-            let block_root = Hash256::from_slice(&root_bytes);
-            if seen_roots.insert(block_root) {
-                let block = store
-                    .get_full_block(&block_root)
-                    .expect("query")
-                    .unwrap_or_else(|| panic!("block missing at slot {slot}"));
-                assert_eq!(
-                    block.canonical_root(),
-                    block_root,
-                    "block root mismatch at slot {slot}"
-                );
-                blocks_by_slot.insert(slot, block);
-            }
-        }
+    for era in 0..target_era {
+        era_dir
+            .import_era_file(&store, era, &spec, None)
+            .unwrap_or_else(|e| panic!("ERA {era}: {e}"));
     }
 
+    let err = era_dir
+        .import_era_file(&store, target_era, &spec, None)
+        .unwrap_err();
     assert!(
-        blocks_by_slot.len() > 700,
-        "expected >700 blocks, got {}",
-        blocks_by_slot.len()
+        err.contains(expected_err),
+        "expected \"{expected_err}\", got: {err}"
     );
-
-    // Verify parent_root chain: each block's parent_root must equal the previous block's root
-    let slots: Vec<_> = blocks_by_slot.keys().copied().collect();
-    for i in 1..slots.len() {
-        let block = &blocks_by_slot[&slots[i]];
-        let prev_block = &blocks_by_slot[&slots[i - 1]];
-        assert_eq!(
-            block.message().parent_root(),
-            prev_block.canonical_root(),
-            "broken hash chain at slot {}: parent_root doesn't match previous block root",
-            slots[i]
-        );
-    }
-
-    // Verify boundary states match ERA file state roots
-    let era_dir_path = test_vectors_dir().join("era");
-    let mut era_files: Vec<_> = std::fs::read_dir(&era_dir_path)
-        .expect("readdir")
-        .filter_map(|e| e.ok())
-        .filter(|e| e.file_name().to_string_lossy().ends_with(".era"))
-        .collect();
-    era_files.sort_by_key(|e| e.file_name());
-
-    for entry in &era_files {
-        let file = std::fs::File::open(entry.path()).expect("open");
-        let era = reth_era::era::file::EraReader::new(file)
-            .read_and_assemble("minimal".to_string())
-            .expect("parse");
-        let state_bytes = era.group.era_state.decompress().expect("decompress");
-        let mut era_state: BeaconState<MinimalEthSpec> =
-            BeaconState::from_ssz_bytes(&state_bytes, &spec).expect("decode");
-        let expected_root = era_state.canonical_root().expect("root");
-        let slot = era_state.slot();
-
-        // Load state from store and verify root matches
-        let mut stored_state = store.load_cold_state_by_slot(slot).expect("load state");
-        assert_eq!(
-            stored_state.slot(),
-            slot,
-            "stored state slot mismatch at slot {slot}"
-        );
-        let stored_root = stored_state.canonical_root().expect("root");
-        assert_eq!(
-            stored_root, expected_root,
-            "state root mismatch at slot {slot}"
-        );
-    }
 }
 
-// =============================================================================
-// PRODUCER TEST — byte-identical output
-// =============================================================================
+fn era3_correct_root_and_slot(spec: &ChainSpec) -> (Hash256, types::Slot) {
+    let era3_file = std::fs::read_dir(test_vectors_dir().join("era"))
+        .expect("readdir")
+        .filter_map(|e| e.ok())
+        .find(|e| e.file_name().to_string_lossy().contains("-00003-"))
+        .expect("ERA 3");
+    let file = std::fs::File::open(era3_file.path()).expect("open");
+    let era = reth_era::era::file::EraReader::new(file)
+        .read_and_assemble("minimal".to_string())
+        .expect("parse");
+    let state_bytes = era.group.era_state.decompress().expect("decompress");
+    let mut state: BeaconState<MinimalEthSpec> =
+        BeaconState::from_ssz_bytes(&state_bytes, spec).expect("decode");
+    let root = state.canonical_root().expect("root");
+    let slot = state.slot();
+    (root, slot)
+}
 
+// Single #[test] to avoid nextest parallel download races.
+// See slashing_protection/tests/interop.rs for the same pattern.
 #[test]
-fn era_producer_output_is_byte_identical() {
+fn era_test_vectors() {
+    consumer_imports_and_verifies();
+    producer_output_is_byte_identical();
+    rejects_corrupted_block_decompression();
+    rejects_corrupted_genesis_state();
+    rejects_corrupted_middle_state();
+    rejects_corrupted_reference_state();
+    rejects_wrong_era_content();
+    rejects_wrong_era_root();
+    rejects_corrupt_block_summary();
+    rejects_wrong_block_root();
+    rejects_mutated_state_with_trusted_root();
+    rejects_wrong_trusted_state_root();
+}
+
+fn load_metadata() -> Metadata {
+    let path = test_vectors_dir().join("metadata.json");
+    let data = std::fs::read_to_string(&path).expect("read metadata.json");
+    serde_json::from_str(&data).expect("parse metadata.json")
+}
+
+fn consumer_imports_and_verifies() {
+    let metadata = load_metadata();
+    let (store, _spec, max_era) = import_all_era_files();
+    let slots_per_era = MinimalEthSpec::slots_per_historical_root() as u64;
+
+    assert_eq!(max_era + 1, metadata.era_count, "era count mismatch");
+
+    // The last indexed slot is (max_era * slots_per_era - 1), since the ERA boundary
+    // state covers [start_slot, end_slot) where end_slot = era_number * slots_per_era.
+    let last_slot = max_era * slots_per_era - 1;
+
+    // Verify head block root matches metadata
+    let head_key = metadata.head_slot.to_be_bytes().to_vec();
+    let head_root_bytes = store
+        .cold_db
+        .get_bytes(DBColumn::BeaconBlockRoots, &head_key)
+        .expect("read head root index")
+        .unwrap_or_else(|| panic!("no block root at head slot {}", metadata.head_slot));
+    let head_root = Hash256::from_slice(&head_root_bytes);
+
+    let expected_head_root_bytes = hex::decode(&metadata.head_root).expect("decode head_root hex");
+    let expected_head_root = Hash256::from_slice(&expected_head_root_bytes);
+    assert_eq!(
+        head_root, expected_head_root,
+        "head root mismatch at slot {}: got {head_root:?}",
+        metadata.head_slot
+    );
+
+    // Verify the head block exists and has the correct root
+    let head_block = store
+        .get_full_block(&head_root)
+        .expect("query head block")
+        .unwrap_or_else(|| panic!("head block missing at slot {}", metadata.head_slot));
+    assert_eq!(head_block.canonical_root(), head_root);
+    assert_eq!(
+        head_block.slot(),
+        Slot::new(metadata.head_slot),
+        "last indexed slot is {last_slot}"
+    );
+}
+
+fn producer_output_is_byte_identical() {
     let (store, _spec, max_era) = import_all_era_files();
     let output = PathBuf::from("/tmp/era_producer_test_output");
     let _ = std::fs::remove_dir_all(&output);
@@ -247,54 +271,19 @@ fn era_producer_output_is_byte_identical() {
     }
 }
 
-// =============================================================================
-// CORRUPTION TESTS — verify specific error messages
-// =============================================================================
-
-fn assert_import_fails(
-    corrupt_file: &str,
-    target_pattern: &str,
-    target_era: u64,
-    expected_err: &str,
-) {
-    let tmp = era_dir_with_corrupt(corrupt_file, target_pattern);
-    let spec = load_test_spec();
-    let era_dir = EraFileDir::new::<MinimalEthSpec>(&tmp.path().join("era"), &spec)
-        .expect("init should succeed");
-    let store = empty_store(&spec);
-
-    for era in 0..target_era {
-        era_dir
-            .import_era_file(&store, era, &spec, None)
-            .unwrap_or_else(|e| panic!("ERA {era}: {e}"));
-    }
-
-    let err = era_dir
-        .import_era_file(&store, target_era, &spec, None)
-        .unwrap_err();
-    assert!(
-        err.contains(expected_err),
-        "expected \"{expected_err}\", got: {err}"
-    );
-}
-
-#[test]
-fn era_rejects_corrupted_block_decompression() {
+fn rejects_corrupted_block_decompression() {
     assert_import_fails("era1-corrupt-block.era", "-00001-", 1, "decompress");
 }
 
-#[test]
-fn era_rejects_corrupted_genesis_state() {
+fn rejects_corrupted_genesis_state() {
     assert_import_fails("era0-corrupt-state.era", "-00000-", 0, "decompress");
 }
 
-#[test]
-fn era_rejects_corrupted_middle_state() {
+fn rejects_corrupted_middle_state() {
     assert_import_fails("era5-corrupt-state.era", "-00005-", 5, "decompress");
 }
 
-#[test]
-fn era_rejects_corrupted_reference_state() {
+fn rejects_corrupted_reference_state() {
     let tmp = era_dir_with_corrupt("era12-corrupt-state.era", "-00012-");
     let spec = load_test_spec();
     match EraFileDir::new::<MinimalEthSpec>(&tmp.path().join("era"), &spec) {
@@ -303,8 +292,7 @@ fn era_rejects_corrupted_reference_state() {
     }
 }
 
-#[test]
-fn era_rejects_wrong_era_content() {
+fn rejects_wrong_era_content() {
     assert_import_fails(
         "era3-wrong-content.era",
         "-00003-",
@@ -313,13 +301,11 @@ fn era_rejects_wrong_era_content() {
     );
 }
 
-#[test]
-fn era_rejects_wrong_era_root() {
+fn rejects_wrong_era_root() {
     assert_import_fails("era0-wrong-root.era", "-00000-", 0, "era root mismatch");
 }
 
-#[test]
-fn era_rejects_corrupt_block_summary() {
+fn rejects_corrupt_block_summary() {
     assert_import_fails(
         "era8-corrupt-block-summary.era",
         "-00008-",
@@ -328,8 +314,7 @@ fn era_rejects_corrupt_block_summary() {
     );
 }
 
-#[test]
-fn era_rejects_wrong_block_root() {
+fn rejects_wrong_block_root() {
     assert_import_fails(
         "era2-wrong-block-root.era",
         "-00002-",
@@ -338,12 +323,7 @@ fn era_rejects_wrong_block_root() {
     );
 }
 
-/// Mutated balance in ERA 3 state → state root doesn't match trusted root.
-/// Without a trusted root, the consumer can't detect this (historical_summaries only
-/// commit to block_roots/state_roots vectors, not full state content).
-/// The trusted state root feature catches it.
-#[test]
-fn era_rejects_mutated_state_with_trusted_root() {
+fn rejects_mutated_state_with_trusted_root() {
     let tmp = era_dir_with_corrupt("era3-wrong-state-root.era", "-00003-");
     let spec = load_test_spec();
     let era_dir = EraFileDir::new::<MinimalEthSpec>(&tmp.path().join("era"), &spec)
@@ -356,23 +336,8 @@ fn era_rejects_mutated_state_with_trusted_root() {
             .unwrap_or_else(|e| panic!("ERA {era}: {e}"));
     }
 
-    // Get the CORRECT state root from the original ERA 3 file
-    let orig_era3 = std::fs::read_dir(test_vectors_dir().join("era"))
-        .expect("readdir")
-        .filter_map(|e| e.ok())
-        .find(|e| e.file_name().to_string_lossy().contains("-00003-"))
-        .expect("ERA 3");
-    let file = std::fs::File::open(orig_era3.path()).expect("open");
-    let era = reth_era::era::file::EraReader::new(file)
-        .read_and_assemble("minimal".to_string())
-        .expect("parse");
-    let state_bytes = era.group.era_state.decompress().expect("decompress");
-    let mut state: BeaconState<MinimalEthSpec> =
-        BeaconState::from_ssz_bytes(&state_bytes, &spec).expect("decode");
-    let correct_root = state.canonical_root().expect("root");
-    let slot = state.slot();
+    let (correct_root, slot) = era3_correct_root_and_slot(&spec);
 
-    // Import mutated ERA 3 with trusted root → should fail because balance was changed
     let err = era_dir
         .import_era_file(&store, 3, &spec, Some((correct_root, slot)))
         .unwrap_err();
@@ -382,12 +347,7 @@ fn era_rejects_mutated_state_with_trusted_root() {
     );
 }
 
-// =============================================================================
-// TRUSTED STATE ROOT VERIFICATION
-// =============================================================================
-
-#[test]
-fn era_rejects_wrong_trusted_state_root() {
+fn rejects_wrong_trusted_state_root() {
     let spec = load_test_spec();
     let store = empty_store(&spec);
     let era_dir_path = test_vectors_dir().join("era");
@@ -399,29 +359,12 @@ fn era_rejects_wrong_trusted_state_root() {
             .unwrap_or_else(|e| panic!("ERA {era}: {e}"));
     }
 
-    // Get correct state root for ERA 3
-    let era3_file = std::fs::read_dir(&era_dir_path)
-        .expect("readdir")
-        .filter_map(|e| e.ok())
-        .find(|e| e.file_name().to_string_lossy().contains("-00003-"))
-        .expect("ERA 3");
+    let (correct_root, slot) = era3_correct_root_and_slot(&spec);
 
-    let file = std::fs::File::open(era3_file.path()).expect("open");
-    let era = reth_era::era::file::EraReader::new(file)
-        .read_and_assemble("minimal".to_string())
-        .expect("parse");
-    let state_bytes = era.group.era_state.decompress().expect("decompress");
-    let mut state: BeaconState<MinimalEthSpec> =
-        BeaconState::from_ssz_bytes(&state_bytes, &spec).expect("decode");
-    let correct_root = state.canonical_root().expect("root");
-    let slot = state.slot();
-
-    // Correct root passes
     era_dir
         .import_era_file(&store, 3, &spec, Some((correct_root, slot)))
         .expect("correct root should pass");
 
-    // Wrong root fails
     let wrong_root = {
         let mut bytes: [u8; 32] = correct_root.into();
         bytes[0] ^= 0x01;