Wire safeTarget store checks in the fork choice test harness so that

  the spec-test runner actually validates safe_target behavior end-to-end.

  Today the harness explicitly rejects any fixture carrying a \'safeTarget\'
  field with "'\safeTarget\' check not supported", and it has no field at all
  for the leanSpec #680 schema (safeTargetSlot, safeTargetRootLabel). The
  result is that the safe_target semantics shipped in PR #316 have no
  fixture-level coverage: regenerated fixtures are silently parsed without
  asserting on the field, and any test using the legacy \'safeTarget\' field
  errors out instead of validating.

  Changes:

  - Add safeTargetSlot and safeTargetRootLabel to StoreChecks, mirroring
    the latestJustified* / latestFinalized* pattern.
  - Replace the rejection branch with the same label-resolution pattern
    used for justified/finalized roots, falling back from safeTarget to
    safeTargetRootLabel via the step\'s block registry.
  - Add validation blocks for safeTargetSlot (against st.safe_target_slot())
    and the resolved root (against st.safe_target()).
  - Reorganize StoreChecks into logical groups and drop the now-stale
    "Unsupported fields (will error if present)" comment, which was
    misleading: only safeTarget actually errored, everything else was
    validated.

  This change is forward-compatible: no current fixture in
  leanSpec/fixtures/consensus/ contains any safeTarget* field, so the new
  validation paths are dormant until LEAN_SPEC_COMMIT_HASH is bumped to a
  revision that includes leanSpec #680.

  Verified with cargo fmt --all, cargo clippy --workspace --all-targets
  -- -D warnings, and the forkchoice_spectests harness (47 passing
  fixtures unchanged). Pre-existing failures from a stale leanSpec
  submodule checkout (1 fork-choice fixture, 34 ssz fixtures) reproduce
  identically on main and are unrelated to this change.

Author: pablodeymo

crates/blockchain/tests/forkchoice_spectests.rs

@@ -221,9 +221,12 @@ fn validate_checks(
             .as_ref()
             .and_then(|label| block_registry.get(label).copied())
     });
-    if checks.safe_target.is_some() {
-        return Err(format!("Step {}: 'safeTarget' check not supported", step_idx).into());
-    }
+    let resolved_safe_target_root = checks.safe_target.or_else(|| {
+        checks
+            .safe_target_root_label
+            .as_ref()
+            .and_then(|label| block_registry.get(label).copied())
+    });
     // Validate attestationTargetSlot
     if let Some(expected_slot) = checks.attestation_target_slot {
         let target = store::get_attestation_target(st);
@@ -330,6 +333,30 @@ fn validate_checks(
         }
     }
 
+    // Validate safeTargetSlot
+    if let Some(expected_slot) = checks.safe_target_slot {
+        let actual_slot = st.safe_target_slot();
+        if actual_slot != expected_slot {
+            return Err(format!(
+                "Step {}: safeTargetSlot mismatch: expected {}, got {}",
+                step_idx, expected_slot, actual_slot
+            )
+            .into());
+        }
+    }
+
+    // Validate safeTarget root (resolved from label if root not provided)
+    if let Some(ref expected_root) = resolved_safe_target_root {
+        let actual_root = st.safe_target();
+        if actual_root != *expected_root {
+            return Err(format!(
+                "Step {}: safeTarget mismatch: expected {:?}, got {:?}",
+                step_idx, expected_root, actual_root
+            )
+            .into());
+        }
+    }
+
     // Validate attestationChecks
     if let Some(ref att_checks) = checks.attestation_checks {
         for att_check in att_checks {

crates/blockchain/tests/types.rs

@@ -136,38 +136,51 @@ impl BlockStepData {
 // Check Types
 // ============================================================================
 
+/// Store-state expectations for a fork choice test step.
+///
+/// All fields are optional; only fields explicitly set by the fixture are validated.
+/// Root-typed fields have a `*RootLabel` companion that resolves a block label via the
+/// step's block registry, mirroring the leanSpec fixture schema.
 #[derive(Debug, Clone, Deserialize)]
 pub struct StoreChecks {
-    // Validated fields
+    /// Expected store time in intervals since genesis.
+    pub time: Option<u64>,
+
     #[serde(rename = "headSlot")]
     pub head_slot: Option<u64>,
     #[serde(rename = "headRoot")]
     pub head_root: Option<H256>,
-    #[serde(rename = "attestationChecks")]
-    pub attestation_checks: Option<Vec<AttestationCheck>>,
-    #[serde(rename = "attestationTargetSlot")]
-    pub attestation_target_slot: Option<u64>,
-
-    /// Expected store time in intervals since genesis (validated when present).
-    pub time: Option<u64>,
-
-    // Unsupported fields (will error if present in test fixture)
     #[serde(rename = "headRootLabel")]
     pub head_root_label: Option<String>,
+
     #[serde(rename = "latestJustifiedSlot")]
     pub latest_justified_slot: Option<u64>,
     #[serde(rename = "latestJustifiedRoot")]
     pub latest_justified_root: Option<H256>,
     #[serde(rename = "latestJustifiedRootLabel")]
     pub latest_justified_root_label: Option<String>,
+
     #[serde(rename = "latestFinalizedSlot")]
     pub latest_finalized_slot: Option<u64>,
     #[serde(rename = "latestFinalizedRoot")]
     pub latest_finalized_root: Option<H256>,
     #[serde(rename = "latestFinalizedRootLabel")]
     pub latest_finalized_root_label: Option<String>,
+
+    /// Legacy single-field schema; expected safe target block root.
     #[serde(rename = "safeTarget")]
     pub safe_target: Option<H256>,
+    /// Expected slot of the safe target block (leanSpec #680 schema).
+    #[serde(rename = "safeTargetSlot")]
+    pub safe_target_slot: Option<u64>,
+    /// Expected safe target block root by label reference (leanSpec #680 schema).
+    #[serde(rename = "safeTargetRootLabel")]
+    pub safe_target_root_label: Option<String>,
+
+    #[serde(rename = "attestationTargetSlot")]
+    pub attestation_target_slot: Option<u64>,
+    #[serde(rename = "attestationChecks")]
+    pub attestation_checks: Option<Vec<AttestationCheck>>,
     #[serde(rename = "lexicographicHeadAmong")]
     pub lexicographic_head_among: Option<Vec<String>>,
 }