feat: pre-compute weights for RPC at 70s and submit on-chain at 90s after boot

- At 70s: compute WASM weights and expose via subnet_getWeights RPC
  so other validators without P2P can fetch weights immediately
- At 90s: submit weights on-chain via CRv4 commit
- Both wait for blockchain sync, active challenges, and WASM readiness
- Prevents waiting up to ~72min for next epoch boundary after restart

Author: echobt

bins/validator-node/src/main.rs

@@ -970,6 +970,12 @@ async fn main() -> Result<()> {
     let mut stale_job_interval = tokio::time::interval(Duration::from_secs(120));
     let mut weight_check_interval = tokio::time::interval(Duration::from_secs(30));
     let mut last_weight_submission_epoch: u64 = 0;
+    let startup_rpc_precompute_delay = tokio::time::sleep(Duration::from_secs(70));
+    tokio::pin!(startup_rpc_precompute_delay);
+    let mut startup_rpc_precomputed = false;
+    let startup_weight_delay = tokio::time::sleep(Duration::from_secs(90));
+    tokio::pin!(startup_weight_delay);
+    let mut startup_weights_submitted = false;
     let mut challenge_sync_interval = tokio::time::interval(Duration::from_secs(30)); // Check every 30s
     let mut last_sync_block: u64 = 0;
     let sync_block_interval: u64 = 1; // Call WASM sync every block, WASM decides frequency internally
@@ -1536,6 +1542,105 @@ async fn main() -> Result<()> {
                 // No-op: weights are submitted in CommitWindowOpen via CRv4
             }
 
+            // Pre-compute weights for RPC 70s after boot so other validators
+            // without P2P can fetch via subnet_getWeights before on-chain submission.
+            _ = &mut startup_rpc_precompute_delay, if !startup_rpc_precomputed => {
+                startup_rpc_precomputed = true;
+                let current_block = state_manager.apply(|state| state.bittensor_block);
+                if current_block == 0 {
+                    warn!("RPC pre-compute skipped: blockchain not yet synced");
+                } else if let Some(ref executor) = wasm_executor {
+                    let challenges: Vec<(String, u8, f64)> = {
+                        let cs = chain_state.read();
+                        cs.wasm_challenge_configs.iter()
+                            .filter(|(_, cfg)| cfg.is_active)
+                            .map(|(id, cfg)| (id.to_string(), cfg.config.mechanism_id, cfg.config.emission_weight))
+                            .collect()
+                    };
+                    if challenges.is_empty() {
+                        warn!("RPC pre-compute skipped: no active challenges loaded");
+                    } else {
+                        let tempo = 360u64;
+                        let netuid_plus_one = (netuid as u64).saturating_add(1);
+                        let epoch = current_block.saturating_add(netuid_plus_one) / (tempo + 1);
+                        let mut precomputed: Vec<(u8, Vec<u16>, Vec<u16>)> = Vec::new();
+                        for (cid, mid, ew) in &challenges {
+                            let ew = ew.clamp(0.0, 1.0);
+                            if ew < 0.001 { continue; }
+                            if let Ok(assignments) = executor.execute_get_weights_with_block(cid, current_block, epoch) {
+                                if assignments.is_empty() { continue; }
+                                let total: f64 = assignments.iter().map(|a| a.weight).sum();
+                                if total <= 0.0 { continue; }
+                                let mut uids = Vec::new();
+                                let mut vals = Vec::new();
+                                let mut assigned = 0.0f64;
+                                for a in &assignments {
+                                    if let Some(uid) = subtensor_client.as_ref().and_then(|c| c.get_uid_for_hotkey(&a.hotkey)) {
+                                        let scaled = (a.weight / total) * ew;
+                                        let v = (scaled * 65535.0).round() as u16;
+                                        if v > 0 { uids.push(uid); vals.push(v); assigned += scaled; }
+                                    }
+                                }
+                                let burn = 1.0 - assigned;
+                                if burn > 0.001 {
+                                    let bv = (burn * 65535.0).round() as u16;
+                                    if let Some(pos) = uids.iter().position(|&u| u == 0) {
+                                        vals[pos] = vals[pos].saturating_add(bv);
+                                    } else { uids.push(0); vals.push(bv); }
+                                }
+                                if !uids.is_empty() {
+                                    let mx = *vals.iter().max().unwrap() as f64;
+                                    if mx > 0.0 && mx < 65535.0 {
+                                        vals = vals.iter().map(|v| ((*v as f64 / mx) * 65535.0).round() as u16).collect();
+                                    }
+                                    precomputed.push((*mid, uids, vals));
+                                }
+                            }
+                        }
+                        if !precomputed.is_empty() {
+                            info!("RPC pre-compute: {} mechanism entries available via subnet_getWeights (70s after boot)", precomputed.len());
+                            let mut cs = chain_state.write();
+                            cs.last_computed_weights = precomputed;
+                        } else {
+                            warn!("RPC pre-compute: no weights computed (WASM returned empty)");
+                        }
+                    }
+                }
+            }
+
+            // Submit weights on-chain 90s after boot (after RPC pre-compute at 70s).
+            _ = &mut startup_weight_delay, if !startup_weights_submitted => {
+                startup_weights_submitted = true;
+                let current_block = state_manager.apply(|state| state.bittensor_block);
+                if current_block == 0 {
+                    warn!("Startup weight submission skipped: blockchain not yet synced");
+                } else if subtensor.is_none() || subtensor_signer.is_none() {
+                    warn!("Startup weight submission skipped: subtensor not connected");
+                } else if wasm_executor.is_none() {
+                    warn!("Startup weight submission skipped: WASM executor not ready");
+                } else {
+                    let has_challenges = {
+                        let cs = chain_state.read();
+                        cs.wasm_challenge_configs.iter().any(|(_, cfg)| cfg.is_active)
+                    };
+                    if !has_challenges {
+                        warn!("Startup weight submission skipped: no active challenges loaded");
+                    } else {
+                        let tempo = 360u64;
+                        let netuid_plus_one = (netuid as u64).saturating_add(1);
+                        let epoch = current_block.saturating_add(netuid_plus_one) / (tempo + 1);
+                        info!("Startup weight submission: epoch {} block {} (90s after boot)", epoch, current_block);
+                        handle_block_event(
+                            BlockSyncEvent::CommitWindowOpen { epoch, block: current_block },
+                            &subtensor, &subtensor_signer, &subtensor_client,
+                            &state_manager, netuid, version_key, &wasm_executor,
+                            &keypair, &chain_state, &storage,
+                            &mut last_weight_submission_epoch,
+                        ).await;
+                    }
+                }
+            }
+
             // Periodic checkpoint
             _ = checkpoint_interval.tick() => {
                 if let Some(handler) = shutdown_handler.as_mut() {

crates/bittensor-integration/src/block_sync.rs

@@ -175,6 +175,7 @@ impl BlockSync {
         // Process events in background
         tokio::spawn(async move {
             let mut was_disconnected = false;
+            let mut first_block_seen = false;
 
             loop {
                 if !*running.read().await {
@@ -190,6 +191,7 @@ impl BlockSync {
                             &current_epoch,
                             &current_phase,
                             &mut was_disconnected,
+                            &mut first_block_seen,
                         )
                         .await;
 
@@ -218,6 +220,7 @@ impl BlockSync {
         current_epoch: &Arc<RwLock<u64>>,
         current_phase: &Arc<RwLock<EpochPhase>>,
         was_disconnected: &mut bool,
+        first_block_seen: &mut bool,
     ) -> bool {
         match event {
             BlockEvent::NewBlock {
@@ -228,6 +231,24 @@ impl BlockSync {
                 *current_epoch.write().await = epoch_info.epoch_number;
                 *current_phase.write().await = epoch_info.phase;
 
+                // On first block after startup, trigger immediate weight submission
+                // so the validator doesn't have to wait for the next epoch boundary.
+                if !*first_block_seen {
+                    *first_block_seen = true;
+                    if epoch_info.commit_reveal_enabled {
+                        info!(
+                            "First block after startup: triggering immediate weight submission (epoch={}, block={})",
+                            epoch_info.epoch_number, block_number
+                        );
+                        let _ = event_tx
+                            .send(BlockSyncEvent::CommitWindowOpen {
+                                epoch: epoch_info.epoch_number,
+                                block: block_number,
+                            })
+                            .await;
+                    }
+                }
+
                 if let Err(e) = event_tx
                     .send(BlockSyncEvent::NewBlock {
                         block_number,
@@ -416,6 +437,7 @@ mod tests {
         let current_epoch = Arc::new(RwLock::new(0));
         let current_phase = Arc::new(RwLock::new(EpochPhase::Evaluation));
         let mut was_disconnected = true;
+        let mut first_block_seen = false;
 
         let epoch_info = sample_epoch_info(123, 9, EpochPhase::CommitWindow);
 
@@ -429,6 +451,7 @@ mod tests {
             &current_epoch,
             &current_phase,
             &mut was_disconnected,
+            &mut first_block_seen,
         )
         .await;
 
@@ -440,10 +463,13 @@ mod tests {
             EpochPhase::CommitWindow
         ));
 
+        // First event: CommitWindowOpen (triggered on first block after startup)
         let first = rx.recv().await.unwrap();
-        assert!(matches!(first, BlockSyncEvent::NewBlock { .. }));
+        assert!(matches!(first, BlockSyncEvent::CommitWindowOpen { .. }));
         let second = rx.recv().await.unwrap();
-        assert!(matches!(second, BlockSyncEvent::Reconnected));
+        assert!(matches!(second, BlockSyncEvent::NewBlock { .. }));
+        let third = rx.recv().await.unwrap();
+        assert!(matches!(third, BlockSyncEvent::Reconnected));
         assert!(!was_disconnected);
     }
 
@@ -454,6 +480,7 @@ mod tests {
         let current_epoch = Arc::new(RwLock::new(0));
         let current_phase = Arc::new(RwLock::new(EpochPhase::Evaluation));
         let mut was_disconnected = false;
+        let mut first_block_seen = false;
 
         let should_break = BlockSync::handle_block_event(
             BlockEvent::PhaseChange {
@@ -467,6 +494,7 @@ mod tests {
             &current_epoch,
             &current_phase,
             &mut was_disconnected,
+            &mut first_block_seen,
         )
         .await;
 
@@ -493,6 +521,7 @@ mod tests {
         let current_epoch = Arc::new(RwLock::new(0));
         let current_phase = Arc::new(RwLock::new(EpochPhase::Evaluation));
         let mut was_disconnected = false;
+        let mut first_block_seen = false;
 
         let should_break = BlockSync::handle_block_event(
             BlockEvent::Stopped,
@@ -501,6 +530,7 @@ mod tests {
             &current_epoch,
             &current_phase,
             &mut was_disconnected,
+            &mut first_block_seen,
         )
         .await;
 
@@ -515,6 +545,7 @@ mod tests {
         let current_epoch = Arc::new(RwLock::new(0));
         let current_phase = Arc::new(RwLock::new(EpochPhase::Evaluation));
         let mut was_disconnected = false;
+        let mut first_block_seen = false;
 
         BlockSync::handle_block_event(
             BlockEvent::EpochTransition(EpochTransition::NewEpoch {
@@ -527,6 +558,7 @@ mod tests {
             &current_epoch,
             &current_phase,
             &mut was_disconnected,
+            &mut first_block_seen,
         )
         .await;
 
@@ -548,6 +580,7 @@ mod tests {
         let current_epoch = Arc::new(RwLock::new(0));
         let current_phase = Arc::new(RwLock::new(EpochPhase::Evaluation));
         let mut was_disconnected = false;
+        let mut first_block_seen = false;
 
         BlockSync::handle_block_event(
             BlockEvent::PhaseChange {
@@ -561,6 +594,7 @@ mod tests {
             &current_epoch,
             &current_phase,
             &mut was_disconnected,
+            &mut first_block_seen,
         )
         .await;
 
@@ -583,6 +617,7 @@ mod tests {
         let current_epoch = Arc::new(RwLock::new(0));
         let current_phase = Arc::new(RwLock::new(EpochPhase::Evaluation));
         let mut was_disconnected = false;
+        let mut first_block_seen = false;
 
         let should_break = BlockSync::handle_block_event(
             BlockEvent::ConnectionError("network wobble".into()),
@@ -591,6 +626,7 @@ mod tests {
             &current_epoch,
             &current_phase,
             &mut was_disconnected,
+            &mut first_block_seen,
         )
         .await;