fix(consensus): prevent blocksync race condition during commit step

When a node is in Commit step for height H and receives NewRound(H+1),
it was incorrectly entering blocksync mode even though it was about to
advance naturally. This caused network-wide deadlocks where the committing
node would wait for a block that couldn't be finalized without its vote.

Add get_tendermint_height_and_step() helper to atomically fetch both values,
and skip blocksync when receiving NewRound(H+1) while in Commit step for H.

Author: michaelgpt

app/src/actors_v2/chain/actor.rs

@@ -32,7 +32,8 @@ use lighthouse_wrapper::types::MainnetEthSpec;
 
 // Tendermint imports
 use super::tendermint::{
-    Commit, ConsensusWAL, TendermintState, TimeoutEvent, TimeoutScheduler, ValidatorSet,
+    Commit, ConsensusWAL, TendermintState, TendermintStep, TimeoutEvent, TimeoutScheduler,
+    ValidatorSet,
 };
 
 pub(crate) const DEFAULT_MAX_PENDING_IMPORTS: usize = 1000;
@@ -466,6 +467,17 @@ impl ChainActor {
         }
     }
 
+    /// Get current Tendermint height and step atomically.
+    /// Returns (height, step). Returns (storage_height, Propose) if Tendermint is not configured.
+    pub async fn get_tendermint_height_and_step(&self) -> Result<(u64, TendermintStep), ChainError> {
+        if let Some(ref tm_state) = self.tendermint_state {
+            let state = tm_state.read().await;
+            Ok((state.height, state.step))
+        } else {
+            Ok((self.state.get_height().await, TendermintStep::Propose))
+        }
+    }
+
     /// Record activity and update metrics
     pub(crate) fn record_activity(&mut self) {
         self.last_activity = Instant::now();

app/src/actors_v2/chain/handlers.rs

@@ -17,6 +17,7 @@ use super::{
         AuxPowParams, BlockSource, ChainManagerMessage, ChainManagerResponse, ChainMessage,
         ChainResponse, CreateAuxBlock, SubmitAuxBlock,
     },
+    tendermint::TendermintStep,
     ChainActor, ChainError,
 };
 
@@ -2349,23 +2350,47 @@ impl Handler<ChainMessage> for ChainActor {
                 let correlation_id = correlation_id.unwrap_or_else(uuid::Uuid::new_v4);
 
                 Box::pin(async move {
-                    // TM-B5 Fix: Check if peer is at a height we haven't reached
-                    let current_height = actor.get_tendermint_height().await.unwrap_or(0);
+                    // Get current height AND step atomically to avoid race condition
+                    let (current_height, current_step) = actor
+                        .get_tendermint_height_and_step()
+                        .await
+                        .unwrap_or((0, TendermintStep::Propose));
+
+                    // Determine if we should enter blocksync
+                    let should_sync = if height > current_height {
+                        // TM-B5 Fix: Don't enter blocksync if we're in Commit step for height H
+                        // and receive NewRound(H+1) - we're about to advance naturally
+                        if height == current_height + 1 && current_step == TendermintStep::Commit {
+                            debug!(
+                                correlation_id = %correlation_id,
+                                announced_height = height,
+                                current_height = current_height,
+                                current_step = ?current_step,
+                                peer_id = ?peer_id,
+                                "NewRound(H+1) received while in Commit step - not behind, continuing commit"
+                            );
+                            false
+                        } else {
+                            // Genuine gap: either gap > 1, or we're not in Commit step
+                            true
+                        }
+                    } else {
+                        false
+                    };
 
-                    if height > current_height {
+                    if should_sync {
                         info!(
                             correlation_id = %correlation_id,
                             announced_height = height,
                             announced_round = round,
                             current_height = current_height,
+                            current_step = ?current_step,
                             peer_id = ?peer_id,
                             "NewRound announcement indicates we're behind - triggering sync"
                         );
 
-                        // Enter blocksync mode and trigger sync
                         actor.enter_blocksync_mode(correlation_id).await;
 
-                        // Trigger sync to catch up
                         if let Some(ref sync_actor) = actor.sync_actor {
                             sync_actor.do_send(crate::actors_v2::network::SyncMessage::StartSync {
                                 start_height: current_height,
@@ -2377,7 +2402,7 @@ impl Handler<ChainMessage> for ChainActor {
                             correlation_id = %correlation_id,
                             announced_height = height,
                             current_height = current_height,
-                            "NewRound announcement for current/past height - ignoring"
+                            "NewRound for current/past height or expected advance - ignoring"
                         );
                     }