refactor: event-driven commit/reveal from Bittensor timing

Major changes:
- Update bittensor-rs to c54fc3d (always emit phase events)
- Remove phase-based commit/reveal triggers from runtime
- Add CommitWindowOpen handler that collects and submits weights
- RevealWindowOpen triggers pending commit reveals
- Add collect_and_get_weights() for event-driven weight collection

This makes evaluation truly continuous - commit/reveal only happen
when Bittensor timing events fire, not based on internal phases.

Author: EchoBT

Cargo.lock

@@ -30,7 +30,7 @@ license = "MIT"
 
 [workspace.dependencies]
 # Bittensor
-bittensor-rs = { git = "https://github.com/CortexLM/bittensor-rs", rev = "c4e6df8ef5005a594a15ec073b9425bc6a6edb09" }
+bittensor-rs = { git = "https://github.com/CortexLM/bittensor-rs", rev = "c54fc3d" }
 
 # Async runtime
 tokio = { version = "1.40", features = ["full", "sync", "macros", "rt-multi-thread"] }

Cargo.toml

@@ -829,6 +829,29 @@ async fn main() -> Result<()> {
                     }
                     BlockSyncEvent::CommitWindowOpen { epoch, block } => {
                         info!("Commit window opened for epoch {} at block {}", epoch, block);
+
+                        // Collect and commit weights for all mechanisms
+                        // This is the primary trigger for weight submission (event-driven from Bittensor)
+                        
+                        // Collect weights from all challenges (async)
+                        let mechanism_weights = runtime_for_blocks.collect_and_get_weights().await;
+                        
+                        if let Some(ref submitter) = weight_submitter_clone {
+                            let weights_to_submit = if mechanism_weights.is_empty() {
+                                // No challenge weights - submit burn weights to UID 0
+                                info!("No challenge weights for epoch {} - submitting burn weights", epoch);
+                                vec![(0u8, vec![0u16], vec![65535u16])]
+                            } else {
+                                info!("Committing weights for {} mechanisms", mechanism_weights.len());
+                                mechanism_weights
+                            };
+
+                            let mut sub = submitter.lock().await;
+                            match sub.submit_mechanism_weights_batch(&weights_to_submit).await {
+                                Ok(tx) => info!("Mechanism weights committed to Bittensor: {}", tx),
+                                Err(e) => error!("Failed to commit mechanism weights: {}", e),
+                            }
+                        }
                     }
                     BlockSyncEvent::RevealWindowOpen { epoch, block } => {
                         info!("Reveal window opened for epoch {} at block {}", epoch, block);

bins/validator-node/src/main.rs

@@ -309,26 +309,12 @@ impl ChallengeRuntime {
         Ok(())
     }
 
-    /// Handle phase change
+    /// Handle phase change - just logs, does not trigger commit/reveal
+    /// 
+    /// Commit/reveal are triggered by Bittensor events (CommitWindowOpen, RevealWindowOpen)
+    /// not by internal phase tracking. This ensures timing matches Bittensor exactly.
     async fn on_phase_change(&self, epoch: u64, phase: EpochPhase) -> Result<(), RuntimeError> {
-        info!("Epoch {} phase: {}", epoch, phase);
-
-        match phase {
-            EpochPhase::Commit => {
-                // Calculate and commit weights for all challenges
-                self.commit_weights(epoch).await?;
-            }
-            EpochPhase::Reveal => {
-                // Reveal weights for all challenges
-                self.reveal_weights(epoch).await?;
-            }
-            EpochPhase::Finalization => {
-                // Finalize weights
-                self.finalize_weights(epoch).await?;
-            }
-            _ => {}
-        }
-
+        info!("Epoch {} phase: {} (info only - actions triggered by Bittensor events)", epoch, phase);
         Ok(())
     }
 
@@ -400,7 +386,9 @@ impl ChallengeRuntime {
     }
 
     /// Commit weights for all mechanisms
-    async fn commit_weights(&self, epoch: u64) -> Result<(), RuntimeError> {
+    /// 
+    /// Called when Bittensor CommitWindowOpen event fires.
+    pub async fn commit_weights(&self, epoch: u64) -> Result<(), RuntimeError> {
         info!("Committing weights for epoch {} (per mechanism)", epoch);
 
         // First collect weights from all challenges
@@ -449,7 +437,9 @@ impl ChallengeRuntime {
     }
 
     /// Reveal weights for all mechanisms
-    async fn reveal_weights(&self, epoch: u64) -> Result<(), RuntimeError> {
+    /// 
+    /// Called when Bittensor RevealWindowOpen event fires.
+    pub async fn reveal_weights(&self, epoch: u64) -> Result<(), RuntimeError> {
         info!("Revealing weights for epoch {} (per mechanism)", epoch);
 
         let all_mechanisms = self.mechanism_weights.read().list_mechanisms();
@@ -524,10 +514,80 @@ impl ChallengeRuntime {
 
     /// Get all mechanism weights for batch submission to Bittensor
     /// Returns Vec<(mechanism_id, uids, weights)> for use with batch_set_mechanism_weights
+    /// 
+    /// Note: This returns revealed weights from internal commit-reveal.
+    /// For direct weights, use collect_and_get_weights() instead.
     pub fn get_mechanism_weights_for_submission(&self) -> Vec<(u8, Vec<u16>, Vec<u16>)> {
         self.mechanism_commit_reveal.get_revealed_weights()
     }
 
+    /// Collect weights from all challenges and return them for Bittensor submission
+    /// 
+    /// This is the primary method for event-driven weight submission.
+    /// Called when Bittensor CommitWindowOpen event fires.
+    pub async fn collect_and_get_weights(&self) -> Vec<(u8, Vec<u16>, Vec<u16>)> {
+        let epoch = self.epoch_manager.current_epoch();
+        info!("Collecting weights for epoch {} (event-driven)", epoch);
+
+        let mut result = Vec::new();
+
+        for challenge_id in self.manager.list_challenges() {
+            let mechanism_id = match self.challenge_mechanisms.read().get(&challenge_id) {
+                Some(id) => *id,
+                None => {
+                    warn!("Challenge {} has no mechanism_id, skipping", challenge_id);
+                    continue;
+                }
+            };
+
+            let ctx = match self.manager.get_context(&challenge_id) {
+                Some(ctx) => ctx,
+                None => continue,
+            };
+
+            let challenge = match self.manager.get_challenge(&challenge_id) {
+                Some(c) => c,
+                None => continue,
+            };
+
+            // Calculate weights from this challenge
+            match challenge.calculate_weights(&ctx).await {
+                Ok(weights) => {
+                    if weights.is_empty() {
+                        debug!("Challenge {} has no weights", challenge_id);
+                        continue;
+                    }
+
+                    info!(
+                        "Challenge {} -> mechanism {}: {} weights",
+                        challenge_id,
+                        mechanism_id,
+                        weights.len()
+                    );
+
+                    // Convert to Bittensor format (uid, weight as u16)
+                    // For now, use placeholder UIDs - actual UID mapping would come from metagraph
+                    let uids: Vec<u16> = (0..weights.len() as u16).collect();
+                    let weight_values: Vec<u16> = weights
+                        .iter()
+                        .map(|w| (w.weight.clamp(0.0, 1.0) * 65535.0) as u16)
+                        .collect();
+
+                    result.push((mechanism_id, uids, weight_values));
+                }
+                Err(e) => {
+                    error!(
+                        "Failed to calculate weights for challenge {}: {}",
+                        challenge_id, e
+                    );
+                }
+            }
+        }
+
+        info!("Collected weights for {} mechanisms", result.len());
+        result
+    }
+
     /// Get all registered mechanism IDs (for initial weight submission)
     pub fn get_registered_mechanism_ids(&self) -> Vec<u8> {
         self.challenge_mechanisms