Merge branch 'main' into feat/chain-events-bus

Author: MegaRedHand

crates/blockchain/src/metrics.rs

@@ -706,9 +706,13 @@ pub fn set_node_start_time() {
     LEAN_NODE_START_TIME_SECONDS.set(timestamp as i64);
 }
 
-/// Increment the valid attestations counter.
-pub fn inc_attestations_valid(count: u64) {
-    LEAN_ATTESTATIONS_VALID_TOTAL.inc_by(count);
+/// Increment the valid attestations counter by one.
+///
+/// Counts one per gossip attestation (single or aggregated) that passes all
+/// validation checks, symmetric with [`inc_attestations_invalid`]. Matches
+/// leanSpec's `lean_attestations_valid_total`, a validation-pipeline counter.
+pub fn inc_attestations_valid() {
+    LEAN_ATTESTATIONS_VALID_TOTAL.inc();
 }
 
 /// Increment the invalid attestations counter.

crates/blockchain/src/store.rs

@@ -427,7 +427,7 @@ pub fn on_gossip_attestation(
         metrics::update_gossip_signatures(store.gossip_signatures_count());
     }
 
-    metrics::inc_attestations_valid(1);
+    metrics::inc_attestations_valid();
 
     let slot = attestation.data.slot;
     let target_slot = attestation.data.target.slot;
@@ -536,7 +536,7 @@ fn on_gossip_aggregated_attestation_core(
         "Aggregated attestation processed"
     );
 
-    metrics::inc_attestations_valid(1);
+    metrics::inc_attestations_valid();
 
     Ok(())
 }
@@ -569,7 +569,7 @@ fn on_block_core(
     signed_block: SignedBlock,
     verify: bool,
 ) -> Result<(), StoreError> {
-    let _timing = metrics::time_fork_choice_block_processing();
+    let timing = metrics::time_fork_choice_block_processing();
     let block_start = std::time::Instant::now();
 
     let block = &signed_block.message;
@@ -581,6 +581,7 @@ fn on_block_core(
         .has_state(&block_root)
         .expect("DB read should succeed")
     {
+        timing.discard();
         return Ok(());
     }
 
@@ -682,11 +683,11 @@ fn on_block_core(
         .insert_state(block_root, post_state)
         .expect("DB insert should succeed");
 
-    for att in block.body.attestations.iter() {
-        // Count each participating validator as a valid attestation.
-        let count = validator_indices(&att.aggregation_bits).count() as u64;
-        metrics::inc_attestations_valid(count);
-    }
+    // Block-included attestations are intentionally not counted here.
+    // `lean_attestations_valid_total` tracks the gossip validation pipeline
+    // (symmetric with `inc_attestations_invalid`), matching leanSpec. Votes
+    // arriving inside a block are counted by
+    // `lean_state_transition_attestations_processed_total` instead.
 
     // Update forkchoice head based on new block and attestations
     update_head(store, false);

crates/blockchain/state_transition/tests/stf_spectests.rs

@@ -53,6 +53,20 @@ fn run(path: &Path) -> datatest_stable::Result<()> {
         match (result, test.post) {
             (Ok(_), Some(expected_post)) => {
                 compare_post_states(&post_state, &expected_post, &block_registry)?;
+                // Hardening: the full post-state hash_tree_root must equal the
+                // fixture's `postStateRoot`. The per-field `post` checks only
+                // pin the fields the fixture chose to enumerate; this catches
+                // any state field they omit.
+                if let Some(expected_root) = test.post_state_root {
+                    let actual_root = post_state.hash_tree_root();
+                    if actual_root != expected_root {
+                        return Err(format!(
+                            "Test '{name}' post-state root mismatch: \
+                             expected {expected_root:?}, got {actual_root:?}"
+                        )
+                        .into());
+                    }
+                }
             }
             (Ok(_), None) => {
                 return Err(

crates/blockchain/state_transition/tests/types.rs

@@ -33,11 +33,10 @@ pub struct StateTransitionTest {
     pub pre: TestState,
     pub blocks: Vec<Block>,
     pub post: Option<PostState>,
-    /// Expected post-state `hash_tree_root`, present alongside `post`. Captured
-    /// only so `deny_unknown_fields` accepts it; the per-field `post` checks
-    /// already pin the post-state.
+    /// Expected post-state `hash_tree_root`, present alongside `post`. Asserted
+    /// against the full post-state root after the per-field `post` checks, so
+    /// any state field those checks don't enumerate is still pinned.
     #[serde(rename = "postStateRoot")]
-    #[allow(dead_code)]
     pub post_state_root: Option<H256>,
     /// Expected rejection reason for negative cases. Captured only so
     /// `deny_unknown_fields` accepts it; failure is asserted via a missing

crates/common/metrics/src/timing.rs

@@ -5,6 +5,11 @@ use std::time::Instant;
 use crate::Histogram;
 
 /// A guard that records elapsed time to a histogram when dropped.
+///
+/// The measurement can be cancelled with [`TimingGuard::discard`], which
+/// consumes the guard without recording a sample, for a timed path that turns
+/// out to be a no-op whose duration would only skew the histogram (e.g. an
+/// idempotent early return).
 pub struct TimingGuard {
     histogram: &'static Histogram,
     start: Instant,
@@ -17,6 +22,22 @@ impl TimingGuard {
             start: Instant::now(),
         }
     }
+
+    /// Consume the guard without recording a sample.
+    ///
+    /// Use when the timed work should not contribute a sample, such as a
+    /// duplicate/idempotent request that returns early: the elapsed time is
+    /// real but recording it would skew the histogram toward near-zero.
+    ///
+    /// `TimingGuard` implements [`Drop`], so its fields cannot be moved out to
+    /// destructure it directly. Wrapping in [`std::mem::ManuallyDrop`] inhibits
+    /// the recording `Drop`; the fields are `Copy`, so they are then read out
+    /// and their copies dropped here, leaving nothing to record.
+    pub fn discard(self) {
+        let guard = std::mem::ManuallyDrop::new(self);
+        let _histogram = guard.histogram;
+        let _start = guard.start;
+    }
 }
 
 impl Drop for TimingGuard {