feat: auto-convert hotkeys to UIDs in weight submission

- challenge_weight_collector.rs: Add HotkeyWeightEntry type for hotkey-based weights
- challenge_weight_collector.rs: Implement convert_hotkeys_to_uids() using metagraph
- challenge_weight_collector.rs: Unknown hotkeys have their weight sent to burn (UID 0)
- challenge_weight_collector.rs: Auto-sync metagraph before weight collection
- runtime.rs: Add collect_and_get_weights_with_mapping() for explicit UID mapping
- mechanism_weights.rs: Add warning when using MechanismWeights without hotkey mapping

Author: echobt

crates/bittensor-integration/src/challenge_weight_collector.rs

@@ -43,15 +43,32 @@ fn default_true() -> bool {
     true
 }
 
+/// Weight entry with hotkey (challenge returns this format)
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct HotkeyWeightEntry {
+    /// Miner hotkey (SS58 address)
+    pub hotkey: String,
+    /// Weight (0.0 - 1.0, normalized)
+    pub weight: f64,
+}
+
 /// Weights response from challenge endpoint
+///
+/// Challenges return weights with hotkeys, not UIDs.
+/// The collector converts hotkeys to UIDs using the metagraph.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ChallengeWeightsResponse {
     /// Epoch these weights are for
     pub epoch: u64,
-    /// UIDs to set weights for
+    /// Weights per miner hotkey (preferred format)
+    #[serde(default)]
+    pub weights: Vec<HotkeyWeightEntry>,
+    /// Legacy: UIDs (if challenge already converted)
+    #[serde(default)]
     pub uids: Vec<u16>,
-    /// Corresponding weights (0-65535 normalized)
-    pub weights: Vec<u16>,
+    /// Legacy: Corresponding weights in u16 format
+    #[serde(default, rename = "weight_values")]
+    pub weight_values: Vec<u16>,
     /// Optional: challenge name
     #[serde(default)]
     pub challenge_name: Option<String>,
@@ -60,6 +77,12 @@ pub struct ChallengeWeightsResponse {
     pub mechanism_id: Option<u8>,
 }
 
+/// UID 0 is the burn address - weights for unknown hotkeys go here
+pub const BURN_UID: u16 = 0;
+
+/// Maximum weight value for Bittensor
+pub const MAX_WEIGHT: u16 = 65535;
+
 /// Result of fetching weights from a single challenge
 #[derive(Clone, Debug)]
 pub struct ChallengeWeightResult {
@@ -153,6 +176,93 @@ impl ChallengeWeightCollector {
         self.status.read().await.clone()
     }
 
+    /// Convert hotkey weights to UID weights using metagraph
+    ///
+    /// - Hotkeys found in metagraph get their corresponding UIDs
+    /// - Hotkeys NOT found have their weight accumulated to UID 0 (burn)
+    /// - Returns (uids, weights) in Bittensor u16 format
+    fn convert_hotkeys_to_uids(
+        &self,
+        hotkey_weights: &[HotkeyWeightEntry],
+    ) -> (Vec<u16>, Vec<u16>) {
+        if hotkey_weights.is_empty() {
+            return (vec![BURN_UID], vec![MAX_WEIGHT]);
+        }
+
+        let mut uid_weight_map: std::collections::HashMap<u16, u64> =
+            std::collections::HashMap::new();
+        let mut burn_weight: f64 = 0.0;
+        let mut resolved_count = 0;
+        let mut unresolved_count = 0;
+
+        for entry in hotkey_weights {
+            // Look up UID from metagraph
+            if let Some(uid) = self.client.get_uid_for_hotkey(&entry.hotkey) {
+                // Skip UID 0 from challenge weights - it's reserved for burn
+                if uid == BURN_UID {
+                    debug!(
+                        "Hotkey {} resolved to UID 0 (burn), adding to burn weight",
+                        entry.hotkey
+                    );
+                    burn_weight += entry.weight;
+                } else {
+                    let weight_u16 = (entry.weight.clamp(0.0, 1.0) * MAX_WEIGHT as f64) as u64;
+                    *uid_weight_map.entry(uid).or_insert(0) += weight_u16;
+                    resolved_count += 1;
+                }
+            } else {
+                // Hotkey not found in metagraph - add weight to burn (UID 0)
+                warn!(
+                    "Hotkey {} not found in metagraph, adding {:.4} weight to burn (UID 0)",
+                    entry.hotkey, entry.weight
+                );
+                burn_weight += entry.weight;
+                unresolved_count += 1;
+            }
+        }
+
+        // Calculate total weight to ensure normalization
+        let total_assigned: u64 = uid_weight_map.values().sum();
+        let burn_weight_u16 = (burn_weight.clamp(0.0, 1.0) * MAX_WEIGHT as f64) as u64;
+
+        // Build final vectors
+        let mut uids = Vec::with_capacity(uid_weight_map.len() + 1);
+        let mut weights = Vec::with_capacity(uid_weight_map.len() + 1);
+
+        // Add burn weight first if any
+        let final_burn = if burn_weight_u16 > 0 || unresolved_count > 0 {
+            // Ensure we don't exceed MAX_WEIGHT total
+            let remaining = MAX_WEIGHT as u64 - total_assigned.min(MAX_WEIGHT as u64);
+            remaining.min(burn_weight_u16) as u16
+        } else {
+            0
+        };
+
+        if final_burn > 0 || uid_weight_map.is_empty() {
+            uids.push(BURN_UID);
+            weights.push(if uid_weight_map.is_empty() {
+                MAX_WEIGHT
+            } else {
+                final_burn
+            });
+        }
+
+        // Add resolved weights
+        for (uid, weight) in uid_weight_map {
+            uids.push(uid);
+            weights.push(weight.min(MAX_WEIGHT as u64) as u16);
+        }
+
+        info!(
+            "Converted {} hotkeys: {} resolved to UIDs, {} unresolved -> burn (UID 0)",
+            hotkey_weights.len(),
+            resolved_count,
+            unresolved_count
+        );
+
+        (uids, weights)
+    }
+
     /// Fetch weights from a single challenge endpoint
     async fn fetch_challenge_weights(
         &self,
@@ -193,32 +303,43 @@ impl ChallengeWeightCollector {
         let duration_ms = start.elapsed().as_millis() as u64;
 
         match result {
-            Ok(Ok(weights)) => {
-                // Verify weights
-                if weights.uids.len() != weights.weights.len() {
-                    return ChallengeWeightResult {
-                        mechanism_id: endpoint.mechanism_id,
-                        challenge_name: endpoint.name.clone(),
-                        uids: vec![],
-                        weights: vec![],
-                        success: false,
-                        error: Some("UIDs and weights length mismatch".to_string()),
-                        duration_ms,
-                    };
-                }
+            Ok(Ok(response)) => {
+                // Check if challenge returned hotkey-based weights (preferred format)
+                let (uids, weights) = if !response.weights.is_empty() {
+                    // Convert hotkeys to UIDs using metagraph
+                    self.convert_hotkeys_to_uids(&response.weights)
+                } else if !response.uids.is_empty() && !response.weight_values.is_empty() {
+                    // Legacy format: challenge already provided UIDs
+                    if response.uids.len() != response.weight_values.len() {
+                        return ChallengeWeightResult {
+                            mechanism_id: endpoint.mechanism_id,
+                            challenge_name: endpoint.name.clone(),
+                            uids: vec![],
+                            weights: vec![],
+                            success: false,
+                            error: Some("UIDs and weights length mismatch".to_string()),
+                            duration_ms,
+                        };
+                    }
+                    (response.uids, response.weight_values)
+                } else {
+                    // No weights returned - default to 100% burn
+                    warn!("Challenge {} returned empty weights", endpoint.name);
+                    (vec![BURN_UID], vec![MAX_WEIGHT])
+                };
 
                 info!(
-                    "Fetched {} weights from {} in {}ms",
-                    weights.uids.len(),
+                    "Fetched weights from {} in {}ms: {} entries",
                     endpoint.name,
-                    duration_ms
+                    duration_ms,
+                    uids.len()
                 );
 
                 ChallengeWeightResult {
                     mechanism_id: endpoint.mechanism_id,
                     challenge_name: endpoint.name.clone(),
-                    uids: weights.uids,
-                    weights: weights.weights,
+                    uids,
+                    weights,
                     success: true,
                     error: None,
                     duration_ms,
@@ -359,11 +480,29 @@ impl ChallengeWeightCollector {
         Ok(tx_hash)
     }
 
+    /// Sync metagraph before weight collection
+    ///
+    /// This MUST be called before collect_and_submit to ensure
+    /// hotkeys can be converted to UIDs correctly.
+    pub async fn sync_metagraph(&mut self) -> Result<()> {
+        info!("Syncing metagraph for hotkey->UID conversion...");
+        self.client.sync_metagraph().await?;
+
+        if let Some(metagraph) = self.client.metagraph() {
+            info!("Metagraph synced: {} neurons", metagraph.neurons.len());
+        }
+        Ok(())
+    }
+
     /// Handle new epoch event
     ///
-    /// Called when a new epoch starts. Collects weights and submits.
-    pub async fn on_new_epoch(&self, epoch: u64) -> Result<String> {
+    /// Called when a new epoch starts. Syncs metagraph, collects weights and submits.
+    pub async fn on_new_epoch(&mut self, epoch: u64) -> Result<String> {
         info!("New epoch {} - starting weight collection", epoch);
+
+        // Sync metagraph to get latest hotkey->UID mappings
+        self.sync_metagraph().await?;
+
         self.collect_and_submit(epoch).await
     }
 
@@ -431,11 +570,56 @@ mod tests {
     }
 
     #[test]
-    fn test_weights_response_serde() {
+    fn test_hotkey_weight_entry_serde() {
+        let entry = HotkeyWeightEntry {
+            hotkey: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY".to_string(),
+            weight: 0.5,
+        };
+
+        let json = serde_json::to_string(&entry).unwrap();
+        let parsed: HotkeyWeightEntry = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(parsed.weight, 0.5);
+        assert!(parsed.hotkey.starts_with("5G"));
+    }
+
+    #[test]
+    fn test_weights_response_with_hotkeys() {
+        // New format: weights with hotkeys
+        let response = ChallengeWeightsResponse {
+            epoch: 100,
+            weights: vec![
+                HotkeyWeightEntry {
+                    hotkey: "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY".to_string(),
+                    weight: 0.6,
+                },
+                HotkeyWeightEntry {
+                    hotkey: "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty".to_string(),
+                    weight: 0.4,
+                },
+            ],
+            uids: vec![],
+            weight_values: vec![],
+            challenge_name: Some("Test".to_string()),
+            mechanism_id: Some(1),
+        };
+
+        let json = serde_json::to_string(&response).unwrap();
+        let parsed: ChallengeWeightsResponse = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(parsed.epoch, 100);
+        assert_eq!(parsed.weights.len(), 2);
+        assert!(parsed.uids.is_empty());
+    }
+
+    #[test]
+    fn test_weights_response_legacy_format() {
+        // Legacy format: UIDs directly
         let response = ChallengeWeightsResponse {
             epoch: 100,
+            weights: vec![],
             uids: vec![1, 2, 3],
-            weights: vec![20000, 30000, 15535],
+            weight_values: vec![20000, 30000, 15535],
             challenge_name: Some("Test".to_string()),
             mechanism_id: Some(1),
         };
@@ -445,5 +629,6 @@ mod tests {
 
         assert_eq!(parsed.epoch, 100);
         assert_eq!(parsed.uids.len(), 3);
+        assert_eq!(parsed.weight_values.len(), 3);
     }
 }

crates/challenge-runtime/src/runtime.rs

@@ -536,7 +536,23 @@ impl ChallengeRuntime {
     ///
     /// This is the primary method for event-driven weight submission.
     /// Called when Bittensor CommitWindowOpen event fires.
+    ///
+    /// # Arguments
+    /// * `hotkey_to_uid` - Optional mapping from SS58 hotkey to Bittensor UID.
+    ///   If None, weights are returned with sequential UIDs (for testing only).
+    ///   In production, pass the metagraph mapping from SubtensorClient::get_uids_for_hotkeys().
     pub async fn collect_and_get_weights(&self) -> Vec<(u8, Vec<u16>, Vec<u16>)> {
+        self.collect_and_get_weights_with_mapping(None).await
+    }
+
+    /// Collect weights with explicit hotkey->UID mapping from metagraph
+    ///
+    /// # Arguments
+    /// * `hotkey_to_uid` - Mapping from SS58 hotkey to Bittensor UID from metagraph
+    pub async fn collect_and_get_weights_with_mapping(
+        &self,
+        hotkey_to_uid: Option<&HashMap<String, u16>>,
+    ) -> Vec<(u8, Vec<u16>, Vec<u16>)> {
         let epoch = self.epoch_manager.current_epoch();
         info!("Collecting weights for epoch {} (event-driven)", epoch);
 
@@ -577,14 +593,41 @@ impl ChallengeRuntime {
                     );
 
                     // 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));
+                    let (uids, weight_values): (Vec<u16>, Vec<u16>) = if let Some(mapping) =
+                        hotkey_to_uid
+                    {
+                        // Use metagraph mapping to convert hotkeys to UIDs
+                        weights
+                            .iter()
+                            .filter_map(|w| {
+                                mapping.get(&w.hotkey).map(|uid| {
+                                    let weight_u16 = (w.weight.clamp(0.0, 1.0) * 65535.0) as u16;
+                                    (*uid, weight_u16)
+                                })
+                            })
+                            .unzip()
+                    } else {
+                        // Fallback: use sequential UIDs (for testing only)
+                        warn!(
+                            "No hotkey->UID mapping provided, using sequential UIDs (testing mode)"
+                        );
+                        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();
+                        (uids, weight_values)
+                    };
+
+                    if !uids.is_empty() {
+                        result.push((mechanism_id, uids, weight_values));
+                    } else {
+                        warn!(
+                            "Challenge {} has {} weights but no valid UIDs found in mapping",
+                            challenge_id,
+                            weights.len()
+                        );
+                    }
                 }
                 Err(e) => {
                     error!(