fix: merge duplicate UIDs in weight computation

If WASM returns the same hotkey multiple times, their weights are now
summed on the same UID instead of pushing duplicate UID entries.
Uses BTreeMap for deterministic UID ordering.
Applied to both CommitWindowOpen handler and RPC pre-compute at 70s.

Author: echobt

bins/validator-node/src/main.rs

@@ -1571,16 +1571,22 @@ async fn main() -> Result<()> {
                                 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();
+                                // Merge duplicate UIDs
+                                let mut uid_map: std::collections::BTreeMap<u16, f64> = std::collections::BTreeMap::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; }
+                                        *uid_map.entry(uid).or_insert(0.0) += scaled;
+                                        assigned += scaled;
                                     }
                                 }
+                                let mut uids = Vec::new();
+                                let mut vals = Vec::new();
+                                for (uid, w) in &uid_map {
+                                    let v = (w * 65535.0).round() as u16;
+                                    if v > 0 { uids.push(*uid); vals.push(v); }
+                                }
                                 let burn = 1.0 - assigned;
                                 if burn > 0.001 {
                                     let bv = (burn * 65535.0).round() as u16;
@@ -3703,8 +3709,9 @@ async fn handle_block_event(
                             Ok(assignments) if !assignments.is_empty() => {
                                 let total_weight: f64 = assignments.iter().map(|a| a.weight).sum();
 
-                                let mut uids: Vec<u16> = Vec::new();
-                                let mut vals: Vec<u16> = Vec::new();
+                                // Use a map to merge duplicate UIDs (same hotkey appearing multiple times)
+                                let mut uid_weight_map: std::collections::BTreeMap<u16, f64> =
+                                    std::collections::BTreeMap::new();
                                 let mut assigned_weight: f64 = 0.0;
 
                                 if total_weight > 0.0 {
@@ -3716,12 +3723,8 @@ async fn handle_block_event(
                                         if let Some(uid) = uid {
                                             let normalized = assignment.weight / total_weight;
                                             let scaled = normalized * emission_weight;
-                                            let weight_u16 = (scaled * 65535.0).round() as u16;
-                                            if weight_u16 > 0 {
-                                                uids.push(uid);
-                                                vals.push(weight_u16);
-                                                assigned_weight += scaled;
-                                            }
+                                            *uid_weight_map.entry(uid).or_insert(0.0) += scaled;
+                                            assigned_weight += scaled;
                                         } else {
                                             warn!(
                                                 "Hotkey {} not found in metagraph, weight goes to burn",
@@ -3731,6 +3734,16 @@ async fn handle_block_event(
                                     }
                                 }
 
+                                let mut uids: Vec<u16> = Vec::new();
+                                let mut vals: Vec<u16> = Vec::new();
+                                for (uid, w) in &uid_weight_map {
+                                    let weight_u16 = (w * 65535.0).round() as u16;
+                                    if weight_u16 > 0 {
+                                        uids.push(*uid);
+                                        vals.push(weight_u16);
+                                    }
+                                }
+
                                 // Remaining weight goes to burn (UID 0)
                                 let burn_weight = 1.0 - assigned_weight;
                                 if burn_weight > 0.001 {