fix(p2p): skip heartbeat broadcast in bootnode mode

Bootnode serves only as P2P relay for peer discovery, not as validator.

Author: echobt

bins/validator-node/src/main.rs

@@ -535,6 +535,7 @@ async fn main() -> Result<()> {
 
     let netuid = args.netuid;
     let version_key = args.version_key;
+    let is_bootnode = args.bootnode;
     let mut heartbeat_interval = tokio::time::interval(Duration::from_secs(30));
     let mut metagraph_interval = tokio::time::interval(Duration::from_secs(300));
     let mut stale_check_interval = tokio::time::interval(Duration::from_secs(60));
@@ -579,33 +580,35 @@ async fn main() -> Result<()> {
                 ).await;
             }
 
-            // Heartbeat - broadcast to other validators
+            // Heartbeat - broadcast to other validators (skip in bootnode mode)
             _ = heartbeat_interval.tick() => {
-                let state_hash = state_manager.state_hash();
-                let sequence = state_manager.sequence();
-                let our_hotkey = keypair.hotkey();
-                
-                // Get our stake from validator set
-                let our_stake = validator_set.stake_for(&our_hotkey);
-                
-                let heartbeat = P2PMessage::Heartbeat(HeartbeatMessage {
-                    validator: our_hotkey,
-                    state_hash,
-                    sequence,
-                    stake: our_stake,
-                    timestamp: chrono::Utc::now().timestamp_millis(),
-                    signature: vec![], // Will be signed by P2P layer
-                });
-                
-                if let Err(e) = p2p_broadcast_tx.send(platform_p2p_consensus::P2PCommand::Broadcast(heartbeat)).await {
-                    warn!("Failed to broadcast heartbeat: {}", e);
+                if !is_bootnode {
+                    let state_hash = state_manager.state_hash();
+                    let sequence = state_manager.sequence();
+                    let our_hotkey = keypair.hotkey();
+                    
+                    // Get our stake from validator set
+                    let our_stake = validator_set.stake_for(&our_hotkey);
+                    
+                    let heartbeat = P2PMessage::Heartbeat(HeartbeatMessage {
+                        validator: our_hotkey,
+                        state_hash,
+                        sequence,
+                        stake: our_stake,
+                        timestamp: chrono::Utc::now().timestamp_millis(),
+                        signature: vec![], // Will be signed by P2P layer
+                    });
+                    
+                    if let Err(e) = p2p_broadcast_tx.send(platform_p2p_consensus::P2PCommand::Broadcast(heartbeat)).await {
+                        warn!("Failed to broadcast heartbeat: {}", e);
+                    }
+                    
+                    debug!("Heartbeat: sequence={}, state_hash={}", sequence, hex::encode(&state_hash[..8]));
                 }
 
-                // Also update validator activity count
+                // Update validator activity count (both bootnode and validators)
                 validator_set.mark_stale_validators();
                 debug!("Active validators: {}", validator_set.active_count());
-                
-                debug!("Heartbeat: sequence={}, state_hash={}", sequence, hex::encode(&state_hash[..8]));
             }
 
             // Periodic state persistence