fix: real-time weight computation for subnet_getWeights RPC

- Add GetWeightsHandler callback to RpcHandler for live weight computation
- compute_weights_for_rpc_with_uid_map() calculates weights on every RPC call
- Shared UID map (hotkey->uid) updated on every metagraph sync
- No more stale/empty cached weights - always returns fresh data

Author: factorydroid

bins/validator-node/src/main.rs

@@ -508,6 +508,11 @@ async fn main() -> Result<()> {
         state_manager.clone(),
     )));
 
+    // Shared UID map (hotkey_ss58 -> uid) updated on every metagraph sync.
+    // Used by the subnet_getWeights RPC handler to resolve hotkeys in real-time.
+    let shared_uid_map: Arc<RwLock<std::collections::HashMap<String, u16>>> =
+        Arc::new(RwLock::new(std::collections::HashMap::new()));
+
     // Connect to Bittensor
     let subtensor: Option<Arc<Subtensor>>;
     let subtensor_signer: Option<Arc<BittensorSigner>>;
@@ -551,6 +556,14 @@ async fn main() -> Result<()> {
                                 "Validator set: {} active validators",
                                 validator_set.active_count()
                             );
+                            // Update shared UID map for real-time weight RPC
+                            {
+                                let mut uid_map = shared_uid_map.write();
+                                uid_map.clear();
+                                for (uid, neuron) in &mg.neurons {
+                                    uid_map.insert(neuron.hotkey.to_string(), *uid as u16);
+                                }
+                            }
                             client.set_metagraph(mg);
                         }
                         Err(e) => warn!("Metagraph sync failed: {}", e),
@@ -616,6 +629,14 @@ async fn main() -> Result<()> {
                                 validator_set.active_count()
                             );
 
+                            // Update shared UID map for real-time weight RPC
+                            {
+                                let mut uid_map = shared_uid_map.write();
+                                uid_map.clear();
+                                for (uid, neuron) in &mg.neurons {
+                                    uid_map.insert(neuron.hotkey.to_string(), *uid as u16);
+                                }
+                            }
                             client.set_metagraph(mg);
                         }
                         Err(e) => warn!("Metagraph sync failed: {}", e),
@@ -841,6 +862,19 @@ async fn main() -> Result<()> {
             rpc_server.rpc_handler().set_route_handler(handler);
         }
 
+        // Wire real-time weight computation for subnet_getWeights RPC
+        {
+            let uid_map = Arc::clone(&shared_uid_map);
+            let cs = Arc::clone(&chain_state);
+            let executor = wasm_executor.clone();
+            let sm = Arc::clone(&state_manager);
+
+            let handler: platform_rpc::GetWeightsHandler = Arc::new(move || {
+                compute_weights_for_rpc_with_uid_map(&executor, &uid_map, &sm, &cs)
+            });
+            rpc_server.rpc_handler().set_get_weights_handler(handler);
+        }
+
         rpc_handler_opt = Some(rpc_server.rpc_handler());
 
         tokio::spawn(async move {
@@ -1079,6 +1113,14 @@ async fn main() -> Result<()> {
                                 info!("Pre-weight metagraph refresh: {} neurons", mg.n);
                                 let our_hk = keypair.hotkey();
                                 update_validator_set_from_metagraph(&mg, &validator_set, &chain_state, &valid_voters, &state_root_consensus, &state_manager, Some(&our_hk));
+                                // Update shared UID map for real-time weight RPC
+                                {
+                                    let mut uid_map = shared_uid_map.write();
+                                    uid_map.clear();
+                                    for (uid, neuron) in &mg.neurons {
+                                        uid_map.insert(neuron.hotkey.to_string(), *uid as u16);
+                                    }
+                                }
                                 if let Some(sc) = subtensor_client.as_mut() {
                                     sc.set_metagraph(mg);
                                 }
@@ -4169,8 +4211,145 @@ async fn handle_network_event(
     }
 }
 
-/// Compute mechanism weights from WASM challenges and cache them in chain_state
-/// so they are available via the `subnet_getWeights` RPC immediately.
+/// Compute mechanism weights in real-time using a shared UID map.
+/// Called by the subnet_getWeights RPC handler on every request.
+fn compute_weights_for_rpc_with_uid_map(
+    wasm_executor: &Option<Arc<WasmChallengeExecutor>>,
+    uid_map: &Arc<RwLock<std::collections::HashMap<String, u16>>>,
+    state_manager: &Arc<StateManager>,
+    chain_state: &Arc<RwLock<platform_core::ChainState>>,
+) -> Vec<(u8, Vec<u16>, Vec<u16>)> {
+    let executor = match wasm_executor.as_ref() {
+        Some(e) => e,
+        None => return Vec::new(),
+    };
+
+    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()
+    };
+
+    let block_height = state_manager.apply(|state| state.bittensor_block);
+    let epoch = {
+        let cs = chain_state.read();
+        cs.epoch
+    };
+
+    let map = uid_map.read();
+    let mut mechanism_weights: Vec<(u8, Vec<u16>, Vec<u16>)> = Vec::new();
+
+    for (cid, mechanism_id, emission_weight) in &challenges {
+        let emission_weight = emission_weight.clamp(0.0, 1.0);
+        if emission_weight < 0.001 {
+            continue;
+        }
+        match executor.execute_get_weights_with_block(cid, block_height, epoch) {
+            Ok(assignments) if !assignments.is_empty() => {
+                let total_weight: f64 = assignments.iter().map(|a| a.weight).sum();
+                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 {
+                    for assignment in &assignments {
+                        if let Some(uid) = map.get(&assignment.hotkey) {
+                            let normalized = assignment.weight / total_weight;
+                            let scaled = normalized * emission_weight;
+                            *uid_weight_map.entry(*uid).or_insert(0.0) += scaled;
+                            assigned_weight += scaled;
+                        }
+                    }
+                }
+
+                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);
+                    }
+                }
+
+                let burn_weight = 1.0 - assigned_weight;
+                if burn_weight > 0.001 {
+                    let burn_u16 = (burn_weight * 65535.0).round() as u16;
+                    if let Some(pos) = uids.iter().position(|&u| u == 0) {
+                        vals[pos] = vals[pos].saturating_add(burn_u16);
+                    } else {
+                        uids.push(0);
+                        vals.push(burn_u16);
+                    }
+                }
+
+                if !uids.is_empty() {
+                    let max_val = *vals.iter().max().unwrap() as f64;
+                    if max_val > 0.0 && max_val < 65535.0 {
+                        vals = vals
+                            .iter()
+                            .map(|v| ((*v as f64 / max_val) * 65535.0).round() as u16)
+                            .collect();
+                    }
+                    mechanism_weights.push((*mechanism_id, uids, vals));
+                } else {
+                    mechanism_weights.push((*mechanism_id, vec![0u16], vec![65535u16]));
+                }
+            }
+            Ok(_) => {
+                mechanism_weights.push((*mechanism_id, vec![0u16], vec![65535u16]));
+            }
+            Err(_) => {
+                mechanism_weights.push((*mechanism_id, vec![0u16], vec![65535u16]));
+            }
+        }
+    }
+
+    // Dedup by mechanism_id (prefer most UIDs)
+    if mechanism_weights.is_empty() {
+        let mechanism_id = {
+            let cs = chain_state.read();
+            cs.mechanism_configs.keys().next().copied().unwrap_or(0u8)
+        };
+        return vec![(mechanism_id, vec![0u16], vec![65535u16])];
+    }
+
+    let mut best: std::collections::BTreeMap<u8, (Vec<u16>, Vec<u16>)> =
+        std::collections::BTreeMap::new();
+    for (mid, uids, vals) in &mechanism_weights {
+        let is_burn = uids.len() == 1 && uids[0] == 0;
+        let replace = match best.get(mid) {
+            None => true,
+            Some((ex, _)) => {
+                let ex_burn = ex.len() == 1 && ex[0] == 0;
+                if is_burn && !ex_burn {
+                    false
+                } else if !is_burn && ex_burn {
+                    true
+                } else {
+                    uids.len() > ex.len()
+                }
+            }
+        };
+        if replace {
+            best.insert(*mid, (uids.clone(), vals.clone()));
+        }
+    }
+    best.into_iter()
+        .map(|(mid, (uids, vals))| (mid, uids, vals))
+        .collect()
+}
+
+/// Compute mechanism weights from WASM challenges and cache them in chain_state.
 /// This is called at startup (first block) and at each epoch transition so that
 /// non-bootstrap validators can always fetch the bootstrap validator's weights.
 fn compute_weights_for_rpc(

crates/rpc-server/src/jsonrpc.rs

@@ -61,6 +61,11 @@ use std::sync::Arc;
 use std::time::Instant;
 use tracing::{debug, info, warn};
 
+/// Handler for computing weights in real-time (called by subnet_getWeights)
+pub type GetWeightsHandler = Arc<
+    dyn Fn() -> Vec<(u8, Vec<u16>, Vec<u16>)> + Send + Sync,
+>;
+
 /// Handler for challenge routes
 pub type ChallengeRouteHandler = Arc<
     dyn Fn(
@@ -187,6 +192,8 @@ pub struct RpcHandler {
     pub broadcast_tx: Arc<RwLock<Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>>>,
     /// Keypair for signing P2P messages (optional, set by validator)
     pub keypair: Arc<RwLock<Option<platform_core::Keypair>>>,
+    /// Real-time weight computation handler
+    pub get_weights_handler: Arc<RwLock<Option<GetWeightsHandler>>>,
 }
 
 impl RpcHandler {
@@ -201,6 +208,7 @@ impl RpcHandler {
             route_handler: Arc::new(RwLock::new(None)),
             broadcast_tx: Arc::new(RwLock::new(None)),
             keypair: Arc::new(RwLock::new(None)),
+            get_weights_handler: Arc::new(RwLock::new(None)),
         }
     }
 
@@ -231,6 +239,10 @@ impl RpcHandler {
         *self.route_handler.write() = Some(handler);
     }
 
+    pub fn set_get_weights_handler(&self, handler: GetWeightsHandler) {
+        *self.get_weights_handler.write() = Some(handler);
+    }
+
     /// Get all registered challenge routes from ChainState
     pub fn get_all_challenge_routes(&self) -> Vec<RegisteredChallengeRoute> {
         let chain = self.chain_state.read();
@@ -1467,18 +1479,17 @@ impl RpcHandler {
     // ==================== Subnet Namespace ====================
 
     fn subnet_get_weights(&self, id: Value) -> JsonRpcResponse {
-        let chain = self.chain_state.read();
-        let weights = &chain.last_computed_weights;
-
-        if weights.is_empty() {
-            return JsonRpcResponse::result(
-                id,
-                json!({
-                    "weights": [],
-                    "message": "No weights computed yet. Weights are calculated at each commit window."
-                }),
-            );
-        }
+        // Compute weights in real-time if handler is available
+        let weights: Vec<(u8, Vec<u16>, Vec<u16>)> = {
+            let handler = self.get_weights_handler.read();
+            if let Some(ref handler) = *handler {
+                handler()
+            } else {
+                // Fallback to cached weights
+                let chain = self.chain_state.read();
+                chain.last_computed_weights.clone()
+            }
+        };
 
         let entries: Vec<Value> = weights
             .iter()