fix(consensus): compute proposer advances from genesis for determinism

Nodes starting at different heights (e.g., after syncing) were computing
different numbers of advances to reach the same (height, round), causing
proposer selection disagreement and consensus stalls.

The fix ensures all nodes compute advances from a fixed genesis point
(height 1, round Nil) on their first select_proposer call, regardless
of their initial_height. This guarantees deterministic proposer selection
across all nodes in the network.

Also fixes a test in execution_bridge.rs that wasn't destructuring the
tuple returned by create_default_bridge().

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: qj0r9j0vc2

crates/consensus/src/proposer_selector.rs

@@ -63,6 +63,11 @@ impl ProposerSelector {
     ///
     /// This method advances the internal priority state to match the target
     /// (height, round) and returns the validator with highest priority.
+    ///
+    /// **IMPORTANT**: To ensure all nodes agree on the proposer regardless of their
+    /// starting point (initial sync vs. running from genesis), advances are computed
+    /// from the ABSOLUTE position (genesis height 1, round Nil), not from the node's
+    /// `initial_height`. This ensures deterministic proposer selection across all nodes.
     pub fn select_proposer<'a>(
         &self,
         validator_set: &'a ConsensusValidatorSet,
@@ -76,8 +81,17 @@ impl ProposerSelector {
 
         let (last_height, last_round) = *last_synced;
 
-        // Calculate total advances needed from last synced point to (height, round)
-        let advances = Self::compute_advances(last_height, last_round, height, round);
+        // Calculate total advances needed from last synced point to (height, round).
+        // If this is the first call (last_synced is at initial_height with Nil round),
+        // we compute advances from GENESIS (height 1, Nil) to ensure all nodes get
+        // the same result regardless of their starting height.
+        let advances = if last_round == Round::Nil && last_proposer.is_none() {
+            // First call: compute absolute advances from genesis
+            Self::compute_advances(ConsensusHeight(1), Round::Nil, height, round)
+        } else {
+            // Subsequent calls: compute relative advances from last synced point
+            Self::compute_advances(last_height, last_round, height, round)
+        };
 
         // Track the proposer from advances (the proposer is determined DURING advance,
         // not after, because advance_one_round penalizes the proposer)
@@ -461,4 +475,52 @@ mod tests {
         );
         assert_eq!(advances, 4, "(1, 0) -> (5, 0) should be 4 advances");
     }
+
+    #[test]
+    fn test_different_initial_heights_agree_on_proposer() {
+        // CRITICAL: Nodes that start at different initial heights (e.g., after syncing)
+        // MUST agree on the proposer for the same (height, round).
+        // This is the root cause of consensus stalls when nodes disagree on proposer.
+        let vs = make_validator_set(&[100, 100, 100]);
+
+        // Node A: started from genesis (height 1)
+        let selector_from_genesis = ProposerSelector::new(&vs, ConsensusHeight(1));
+
+        // Node B: synced and started at height 34 (simulating a node that joined later)
+        let selector_synced = ProposerSelector::new(&vs, ConsensusHeight(34));
+
+        // Both query for the proposer at height 34, round 6
+        let proposer_genesis = selector_from_genesis.select_proposer(&vs, ConsensusHeight(34), Round::new(6));
+        let proposer_synced = selector_synced.select_proposer(&vs, ConsensusHeight(34), Round::new(6));
+
+        assert_eq!(
+            proposer_genesis.address, proposer_synced.address,
+            "Nodes starting at different heights MUST agree on the proposer for the same (height, round)"
+        );
+    }
+
+    #[test]
+    fn test_synced_node_continues_correctly() {
+        // After initial query, synced node should continue correctly for subsequent rounds
+        let vs = make_validator_set(&[100, 100, 100]);
+
+        // Genesis node goes through all heights
+        let selector_genesis = ProposerSelector::new(&vs, ConsensusHeight(1));
+        for h in 1..34 {
+            selector_genesis.select_proposer(&vs, ConsensusHeight(h), Round::new(0));
+        }
+        let gen_h34_r0 = selector_genesis.select_proposer(&vs, ConsensusHeight(34), Round::new(0));
+        let gen_h34_r1 = selector_genesis.select_proposer(&vs, ConsensusHeight(34), Round::new(1));
+        let gen_h34_r2 = selector_genesis.select_proposer(&vs, ConsensusHeight(34), Round::new(2));
+
+        // Synced node starts at height 34
+        let selector_synced = ProposerSelector::new(&vs, ConsensusHeight(34));
+        let sync_h34_r0 = selector_synced.select_proposer(&vs, ConsensusHeight(34), Round::new(0));
+        let sync_h34_r1 = selector_synced.select_proposer(&vs, ConsensusHeight(34), Round::new(1));
+        let sync_h34_r2 = selector_synced.select_proposer(&vs, ConsensusHeight(34), Round::new(2));
+
+        assert_eq!(gen_h34_r0.address, sync_h34_r0.address, "Must agree on round 0");
+        assert_eq!(gen_h34_r1.address, sync_h34_r1.address, "Must agree on round 1");
+        assert_eq!(gen_h34_r2.address, sync_h34_r2.address, "Must agree on round 2");
+    }
 }

crates/node/src/execution_bridge.rs

@@ -787,7 +787,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_set_genesis_block_hash() {
-        let bridge = create_default_bridge().unwrap();
+        let (bridge, _temp_dir) = create_default_bridge().unwrap();
 
         // Initially should be B256::ZERO
         let initial_hash = bridge.last_block_hash.read().map(|guard| *guard).unwrap();