fix(validator): add BlockSync reconnection + startup weight submission

- BlockSync now reconnects on health check failure (not just subtensor)
- Weights submitted immediately at startup (not just hourly)
- Prevents complete block event starvation after WebSocket death
- Fresh BlockSync ensures blocks resume flowing after reconnect

Both issues could leave validator in zombie state:
1. Old: BlockSync never reconnected, only metagraph client
2. Old: No weights at startup, waited up to 60min for first submit

Author: echobt

bins/validator-node/src/main.rs

@@ -543,6 +543,7 @@ async fn main() -> Result<()> {
     let mut subtensor_client: Option<SubtensorClient>;
     let mut bittensor_client_for_metagraph: Option<Arc<BittensorClient>>;
     let mut block_rx: Option<tokio::sync::mpsc::Receiver<BlockSyncEvent>> = None;
+    let block_sync_netuid: u16 = args.netuid;
     let mut weight_task_handle: Option<WeightTaskHandle> = None;
     let mut background_weight_handler: Option<BackgroundWeightHandler> = None;
     let mut standalone_weight_submitter: Option<Arc<StandaloneWeightSubmitter>> = None;
@@ -2326,6 +2327,33 @@ async fn main() -> Result<()> {
                                 error!("Failed to recreate Bittensor client during health-check: {}", e);
                             }
                         }
+                        // Recreate BlockSync to get fresh block events
+                        info!("Recreating BlockSync with fresh connection...");
+                        let mut sync = BlockSync::new(BlockSyncConfig {
+                            netuid: block_sync_netuid,
+                            ..Default::default()
+                        });
+                        let rx = sync.take_event_receiver();
+
+                        match bittensor_client_for_metagraph.as_ref() {
+                            Some(client) => {
+                                if let Err(e) = sync.connect(client.clone()).await {
+                                    error!("Failed to reconnect BlockSync: {}", e);
+                                } else {
+                                    tokio::spawn(async move {
+                                        if let Err(e) = sync.start().await {
+                                            error!("Block sync error after reconnect: {}", e);
+                                        }
+                                    });
+                                    block_rx = rx;
+                                    last_block_event_time = std::time::Instant::now();
+                                    info!("BlockSync reconnected successfully");
+                                }
+                            }
+                            None => {
+                                warn!("No bittensor_client_for_metagraph available for BlockSync reconnection");
+                            }
+                        }
                     }
                 }
             }

bins/validator-node/src/standalone_weight_submitter.rs

@@ -104,9 +104,23 @@ impl StandaloneWeightSubmitter {
 
         info!(
             url = WEIGHT_RPC_URL,
-            "Standalone weight submitter started (hourly at :00)"
+            "Standalone weight submitter started (hourly at :00 + startup)"
         );
 
+        info!("Submitting weights at startup...");
+        match self.submit_with_retry().await {
+            Ok(()) => {
+                let now = Utc::now();
+                let hour_epoch = now.timestamp() / 3600;
+                let mut last = self.last_submission_hour.lock().await;
+                *last = Some(hour_epoch);
+                info!(hour = hour_epoch, "Startup weights submitted successfully");
+            }
+            Err(e) => {
+                error!(error = %e, "Failed to submit weights at startup (will retry at next hourly checkpoint)");
+            }
+        }
+        
         loop {
             interval.tick().await;