fix: merge weights by mechanism_id to avoid nonce conflicts in CRv4 commit

Multiple challenges producing weights for the same mechanism_id caused
duplicate transactions in the mempool (Priority too low: 1014 error).
Now weights are merged per mechanism_id before submission.

Author: echobt

bins/validator-node/src/main.rs

@@ -660,6 +660,13 @@ async fn main() -> Result<()> {
 
     // Cast storage to trait object for WASM executor
     let storage_dyn: Arc<dyn DistributedStore> = Arc::clone(&storage) as Arc<dyn DistributedStore>;
+
+    // Shared chain state data for WASM instances
+    let shared_llm_validators_json: Arc<parking_lot::RwLock<Vec<u8>>> =
+        Arc::new(parking_lot::RwLock::new(Vec::new()));
+    let shared_registered_hotkeys_json: Arc<parking_lot::RwLock<Vec<u8>>> =
+        Arc::new(parking_lot::RwLock::new(Vec::new()));
+
     let wasm_executor = match WasmChallengeExecutor::new(WasmExecutorConfig {
         module_dir: wasm_module_dir.clone(),
         max_memory_bytes: args.wasm_max_memory,
@@ -674,6 +681,8 @@ async fn main() -> Result<()> {
         )),
         chutes_api_key: args.chutes_api_key.clone(),
         distributed_storage: Some(storage_dyn),
+        llm_validators_json: Arc::clone(&shared_llm_validators_json),
+        registered_hotkeys_json: Arc::clone(&shared_registered_hotkeys_json),
     }) {
         Ok(executor) => {
             info!(
@@ -985,6 +994,8 @@ async fn main() -> Result<()> {
                     &p2p_cmd_tx,
                     &chain_state,
                     &challenge_last_sync,
+                    &shared_llm_validators_json,
+                    &shared_registered_hotkeys_json,
                 ).await;
             }
 
@@ -1368,6 +1379,9 @@ async fn main() -> Result<()> {
                         stake: our_stake,
                         timestamp: chrono::Utc::now().timestamp_millis(),
                         signature: vec![], // Will be signed by P2P layer
+                        capabilities: platform_p2p_consensus::ValidatorCapabilities {
+                            has_llm: args.chutes_api_key.is_some(),
+                        },
                     });
 
                     if let Err(e) = p2p_broadcast_tx.send(platform_p2p_consensus::P2PCommand::Broadcast(heartbeat)).await {
@@ -1844,6 +1858,8 @@ async fn handle_network_event(
     p2p_cmd_tx: &tokio::sync::mpsc::Sender<platform_p2p_consensus::P2PCommand>,
     chain_state: &Arc<RwLock<platform_core::ChainState>>,
     challenge_last_sync: &Arc<RwLock<std::collections::HashMap<platform_core::ChallengeId, u64>>>,
+    shared_llm_validators_json: &Arc<parking_lot::RwLock<Vec<u8>>>,
+    shared_registered_hotkeys_json: &Arc<parking_lot::RwLock<Vec<u8>>>,
 ) {
     match event {
         NetworkEvent::Message { source, message } => match message {
@@ -1932,6 +1948,33 @@ async fn handle_network_event(
                         .validators
                         .insert(hb.validator.clone(), validator_info);
 
+                    // Track LLM-capable validators
+                    if hb.capabilities.has_llm {
+                        state.llm_capable_validators.insert(hb.validator.clone());
+                    } else {
+                        state.llm_capable_validators.remove(&hb.validator);
+                    }
+
+                    // Update shared WASM-accessible chain state
+                    if let Ok(json) = serde_json::to_vec(
+                        &state
+                            .llm_capable_validators
+                            .iter()
+                            .map(|h| h.to_ss58())
+                            .collect::<Vec<_>>(),
+                    ) {
+                        *shared_llm_validators_json.write() = json;
+                    }
+                    if let Ok(json) = serde_json::to_vec(
+                        &state
+                            .registered_hotkeys
+                            .iter()
+                            .map(|h| h.to_ss58())
+                            .collect::<Vec<_>>(),
+                    ) {
+                        *shared_registered_hotkeys_json.write() = json;
+                    }
+
                     // Check core state hash divergence
                     let our_core_hash = state.state_hash;
                     drop(state);
@@ -3626,16 +3669,54 @@ async fn handle_block_event(
                     }
                 }
 
-                // Submit weights (or burn if none)
-                let weights_to_submit = if mechanism_weights.is_empty() {
+                // Merge weights by mechanism_id before submitting.
+                // Multiple challenges may produce weights for the same mechanism;
+                // we must merge them into a single submission to avoid nonce conflicts.
+                let weights_to_submit: Vec<(u8, Vec<u16>, Vec<u16>)> = if mechanism_weights
+                    .is_empty()
+                {
                     let mechanism_id = {
                         let cs = chain_state.read();
                         cs.mechanism_configs.keys().next().copied().unwrap_or(0u8)
                     };
                     info!("No weights - submitting burn weights to UID 0");
                     vec![(mechanism_id, vec![0u16], vec![65535u16])]
                 } else {
-                    mechanism_weights
+                    use std::collections::HashMap;
+                    let mut merged: HashMap<u8, HashMap<u16, u64>> = HashMap::new();
+                    for (mid, uids, vals) in &mechanism_weights {
+                        let entry = merged.entry(*mid).or_default();
+                        for (uid, val) in uids.iter().zip(vals.iter()) {
+                            *entry.entry(*uid).or_default() += *val as u64;
+                        }
+                    }
+                    let mut result = Vec::new();
+                    for (mid, uid_map) in merged {
+                        let max_val = uid_map.values().copied().max().unwrap_or(1).max(1);
+                        let mut uids = Vec::new();
+                        let mut vals = Vec::new();
+                        for (uid, val) in &uid_map {
+                            let scaled = ((*val as f64 / max_val as f64) * 65535.0).round() as u16;
+                            if scaled > 0 {
+                                uids.push(*uid);
+                                vals.push(scaled);
+                            }
+                        }
+                        if !uids.is_empty() {
+                            info!("Merged weights for mechanism {}: {} UIDs", mid, uids.len());
+                            debug!("  Merged UIDs: {:?}, Weights: {:?}", uids, vals);
+                            result.push((mid, uids, vals));
+                        }
+                    }
+                    if result.is_empty() {
+                        let mechanism_id = {
+                            let cs = chain_state.read();
+                            cs.mechanism_configs.keys().next().copied().unwrap_or(0u8)
+                        };
+                        vec![(mechanism_id, vec![0u16], vec![65535u16])]
+                    } else {
+                        result
+                    }
                 };
 
                 for (mechanism_id, uids, weights) in weights_to_submit {

bins/validator-node/src/wasm_executor.rs

@@ -27,6 +27,10 @@ pub struct WasmExecutorConfig {
     pub chutes_api_key: Option<String>,
     /// Optional distributed storage for loading WASM modules
     pub distributed_storage: Option<Arc<dyn platform_distributed_storage::DistributedStore>>,
+    /// Shared chain state: LLM-capable validators (JSON bytes)
+    pub llm_validators_json: Arc<parking_lot::RwLock<Vec<u8>>>,
+    /// Shared chain state: registered hotkeys (JSON bytes)
+    pub registered_hotkeys_json: Arc<parking_lot::RwLock<Vec<u8>>>,
 }
 
 impl std::fmt::Debug for WasmExecutorConfig {
@@ -55,6 +59,8 @@ impl Default for WasmExecutorConfig {
             storage_backend: Arc::new(InMemoryStorageBackend::new()),
             chutes_api_key: None,
             distributed_storage: None,
+            llm_validators_json: Arc::new(parking_lot::RwLock::new(Vec::new())),
+            registered_hotkeys_json: Arc::new(parking_lot::RwLock::new(Vec::new())),
         }
     }
 }
@@ -780,6 +786,8 @@ impl WasmChallengeExecutor {
                 Some(key) => LlmPolicy::with_api_key(key.clone()),
                 None => LlmPolicy::default(),
             },
+            llm_validators_json: self.config.llm_validators_json.read().clone(),
+            registered_hotkeys_json: self.config.registered_hotkeys_json.read().clone(),
             ..Default::default()
         };
 

crates/challenge-sdk-wasm/src/host_functions.rs

@@ -311,6 +311,8 @@ extern "C" {
     fn consensus_get_submission_count() -> i32;
     fn consensus_get_block_height() -> i64;
     fn consensus_get_subnet_challenges(buf_ptr: i32, buf_len: i32) -> i32;
+    fn consensus_get_llm_validators(buf_ptr: i32, buf_len: i32) -> i32;
+    fn consensus_get_registered_hotkeys(buf_ptr: i32, buf_len: i32) -> i32;
 }
 
 pub fn host_consensus_get_epoch() -> i64 {
@@ -372,3 +374,28 @@ pub fn host_consensus_get_subnet_challenges() -> Result<Vec<u8>, i32> {
     buf.truncate(status as usize);
     Ok(buf)
 }
+
+/// Get the list of validators that have LLM capability (Chutes API key).
+/// Returns JSON-encoded list of hotkey strings.
+pub fn host_consensus_get_llm_validators() -> Result<Vec<u8>, i32> {
+    let mut buf = vec![0u8; RESPONSE_BUF_MEDIUM];
+    let status = unsafe { consensus_get_llm_validators(buf.as_mut_ptr() as i32, buf.len() as i32) };
+    if status < 0 {
+        return Err(status);
+    }
+    buf.truncate(status as usize);
+    Ok(buf)
+}
+
+/// Get the list of all registered hotkeys from the subnet metagraph.
+/// Returns JSON-encoded list of hotkey strings.
+pub fn host_consensus_get_registered_hotkeys() -> Result<Vec<u8>, i32> {
+    let mut buf = vec![0u8; RESPONSE_BUF_MEDIUM];
+    let status =
+        unsafe { consensus_get_registered_hotkeys(buf.as_mut_ptr() as i32, buf.len() as i32) };
+    if status < 0 {
+        return Err(status);
+    }
+    buf.truncate(status as usize);
+    Ok(buf)
+}

crates/core/src/state.rs

@@ -206,6 +206,10 @@ pub struct ChainState {
     /// Monotonic mutation sequence number for deterministic ordering
     #[serde(default)]
     pub mutation_sequence: u64,
+
+    /// Validators that have announced LLM inference capability (Chutes API key)
+    #[serde(default, with = "hotkey_set_serde")]
+    pub llm_capable_validators: std::collections::HashSet<Hotkey>,
 }
 
 /// Route information for a challenge
@@ -242,6 +246,7 @@ impl Default for ChainState {
             paused: false,
             pause_reason: None,
             mutation_sequence: 0,
+            llm_capable_validators: std::collections::HashSet::new(),
         }
     }
 }
@@ -268,6 +273,7 @@ impl ChainState {
             paused: false,
             pause_reason: None,
             mutation_sequence: 0,
+            llm_capable_validators: std::collections::HashSet::new(),
         };
         state.update_hash();
         state

crates/core/src/state_versioning.rs

@@ -162,6 +162,7 @@ impl ChainStateV1 {
             paused: false,
             pause_reason: None,
             mutation_sequence: 0,
+            llm_capable_validators: HashSet::new(),
         }
     }
 }
@@ -216,6 +217,7 @@ impl ChainStateV2 {
             paused: false,
             pause_reason: None,
             mutation_sequence: 0,
+            llm_capable_validators: HashSet::new(),
         }
     }
 }

crates/p2p-consensus/src/lib.rs

@@ -54,7 +54,8 @@ pub use messages::{
     StateChangeType, StateMutationProposalMessage, StateMutationType, StateMutationVoteMessage,
     StateRequest, StateResponse, StorageProposalMessage, StorageRootSyncMessage, StorageSyncEntry,
     StorageSyncRequestMessage, StorageSyncResponseMessage, StorageVoteMessage, SubmissionMessage,
-    TaskProgressMessage, TaskResultMessage, ViewChangeMessage, ViewNumber, WeightVoteMessage,
+    TaskProgressMessage, TaskResultMessage, ValidatorCapabilities, ViewChangeMessage, ViewNumber,
+    WeightVoteMessage,
 };
 pub use network::{
     CombinedBehaviour, CombinedEvent, NetworkBehaviour, NetworkError, NetworkEvent, NetworkRunner,

crates/p2p-consensus/src/messages.rs

@@ -432,6 +432,17 @@ pub struct HeartbeatMessage {
     pub timestamp: i64,
     /// Signature
     pub signature: Vec<u8>,
+    /// Validator capabilities (e.g. LLM inference available)
+    #[serde(default)]
+    pub capabilities: ValidatorCapabilities,
+}
+
+/// Capabilities announced by a validator in heartbeats
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct ValidatorCapabilities {
+    /// Whether this validator has a Chutes API key for LLM inference
+    #[serde(default)]
+    pub has_llm: bool,
 }
 
 /// Peer announcement for discovery
@@ -894,6 +905,7 @@ mod tests {
             stake: 1_000_000_000_000,
             timestamp: 1234567890,
             signature: vec![0u8; 64],
+            capabilities: Default::default(),
         });
 
         let bytes = msg.to_bytes().expect("serialization should work");
@@ -926,6 +938,7 @@ mod tests {
             stake: 0,
             timestamp: 0,
             signature: vec![],
+            capabilities: Default::default(),
         });
         assert_eq!(heartbeat.type_name(), "Heartbeat");
     }
@@ -971,6 +984,7 @@ mod tests {
                 stake: 0,
                 timestamp: 0,
                 signature: vec![],
+                capabilities: Default::default(),
             }),
             signer: Hotkey([1u8; 32]),
             signature: vec![],