feat: add sudo rename-challenge command

- Add RenameChallenge variant to SudoAction enum
- Add rename_challenge() method to both ChainState implementations
- Add 'rename' command to platform-sudo CLI
- Handle rename action in RPC sudo handler and P2P message processing
- Storage unaffected: uses UUID namespace, not name

Author: echobt

bins/platform-sudo/src/main.rs

@@ -53,6 +53,15 @@ enum Commands {
         #[arg(short, long)]
         id: String,
     },
+    /// Rename a challenge (storage unaffected - uses UUID)
+    Rename {
+        /// Challenge ID (UUID)
+        #[arg(short, long)]
+        id: String,
+        /// New name for the challenge
+        #[arg(short, long)]
+        name: String,
+    },
     /// List all challenges
     List,
     /// Show validator status
@@ -242,6 +251,47 @@ impl SudoCli {
         Ok(())
     }
 
+    async fn rename_challenge(&self, challenge_id: &str, new_name: &str) -> Result<()> {
+        let timestamp = chrono::Utc::now().timestamp_millis();
+        let challenge_id = ChallengeId::from_string(challenge_id);
+
+        // Sign the message
+        let msg_to_sign = format!("sudo:rename:{}:{}:{}", challenge_id, new_name, timestamp);
+        let signature = self.sign(msg_to_sign.as_bytes())?;
+
+        let request = SudoRequest {
+            action: "rename".to_string(),
+            challenge_id: challenge_id.to_string(),
+            data: None,
+            name: Some(new_name.to_string()),
+            signature: hex::encode(&signature),
+            timestamp,
+        };
+
+        let response = self
+            .client
+            .post(format!("{}/sudo/challenge", self.rpc_url))
+            .json(&request)
+            .send()
+            .await
+            .context("Failed to send request")?;
+
+        if response.status().is_success() {
+            let result: SudoResponse = response.json().await?;
+            if result.success {
+                info!(challenge_id = %challenge_id, new_name = new_name, "Challenge renamed");
+            } else {
+                warn!(message = %result.message, "Rename failed");
+            }
+        } else {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            error!(status = %status, body = %text, "RPC request failed");
+        }
+
+        Ok(())
+    }
+
     async fn list_challenges(&self) -> Result<()> {
         let response = self
             .client
@@ -390,6 +440,9 @@ async fn main() -> Result<()> {
         Some(Commands::Deactivate { id }) => {
             sudo_cli.set_challenge_status(&id, false).await?;
         }
+        Some(Commands::Rename { id, name }) => {
+            sudo_cli.rename_challenge(&id, &name).await?;
+        }
         Some(Commands::List) => {
             sudo_cli.list_challenges().await?;
         }

bins/validator-node/src/main.rs

@@ -931,6 +931,24 @@ async fn main() -> Result<()> {
                                     }
                                 }
                                 } // end if is_valid
+                            } else if update_type == "rename" && !data.is_empty() {
+                                // Handle rename action
+                                if let Ok(new_name) = String::from_utf8(data) {
+                                    let mut cs = chain_state.write();
+                                    if cs.rename_challenge(&challenge_id, new_name.clone()) {
+                                        info!(
+                                            challenge_id = %challenge_id,
+                                            new_name = %new_name,
+                                            "Challenge renamed locally"
+                                        );
+                                    } else {
+                                        warn!(
+                                            challenge_id = %challenge_id,
+                                            new_name = %new_name,
+                                            "Failed to rename challenge - not found or name conflict"
+                                        );
+                                    }
+                                }
                             }
                         }
                     }
@@ -1628,6 +1646,24 @@ async fn handle_network_event(
                             });
                             info!(challenge_id = %update.challenge_id, "Challenge deactivated");
                         }
+                        "rename" => {
+                            if let Ok(new_name) = String::from_utf8(update.data.clone()) {
+                                let mut cs = chain_state.write();
+                                if cs.rename_challenge(&update.challenge_id, new_name.clone()) {
+                                    info!(
+                                        challenge_id = %update.challenge_id,
+                                        new_name = %new_name,
+                                        "Challenge renamed via P2P"
+                                    );
+                                } else {
+                                    warn!(
+                                        challenge_id = %update.challenge_id,
+                                        new_name = %new_name,
+                                        "Failed to rename challenge - not found or name conflict"
+                                    );
+                                }
+                            }
+                        }
                         other => {
                             warn!(
                                 challenge_id = %update.challenge_id,

crates/core/src/message.rs

@@ -329,6 +329,12 @@ pub enum SudoAction {
 
     /// Force state update (for recovery)
     ForceStateUpdate { state: ChainState },
+
+    /// Rename a challenge (storage unaffected - uses UUID)
+    RenameChallenge {
+        challenge_id: ChallengeId,
+        new_name: String,
+    },
 }
 
 /// Configuration for how weights are distributed on a mechanism

crates/core/src/state.rs

@@ -313,6 +313,36 @@ impl ChainState {
         self.challenge_routes.get(challenge_id)
     }
 
+    /// Rename a challenge (storage unaffected - uses UUID namespace)
+    pub fn rename_challenge(&mut self, id: &ChallengeId, new_name: String) -> bool {
+        // Check name uniqueness in wasm_challenge_configs
+        let name_exists = self
+            .wasm_challenge_configs
+            .values()
+            .any(|c| c.name == new_name && c.challenge_id != *id);
+        if name_exists {
+            return false;
+        }
+
+        // Update in wasm_challenge_configs
+        if let Some(config) = self.wasm_challenge_configs.get_mut(id) {
+            tracing::info!(challenge_id = %id, old_name = %config.name, new_name = %new_name, "Renaming WASM challenge");
+            config.name = new_name.clone();
+            self.update_hash();
+            return true;
+        }
+
+        // Also check legacy challenges
+        if let Some(config) = self.challenges.get_mut(id) {
+            tracing::info!(challenge_id = %id, old_name = %config.name, new_name = %new_name, "Renaming legacy challenge");
+            config.name = new_name;
+            self.update_hash();
+            return true;
+        }
+
+        false
+    }
+
     /// Create a snapshot of the state
     pub fn snapshot(&self) -> StateSnapshot {
         StateSnapshot {

crates/p2p-consensus/src/state.rs

@@ -438,6 +438,28 @@ impl ChainState {
         }
     }
 
+    /// Rename a challenge (storage unaffected - uses UUID namespace)
+    pub fn rename_challenge(&mut self, id: &ChallengeId, new_name: String) -> bool {
+        // Check name uniqueness
+        let name_exists = self
+            .challenges
+            .values()
+            .any(|c| c.name == new_name && c.id != *id);
+        if name_exists {
+            return false;
+        }
+
+        // Update challenge name
+        if let Some(config) = self.challenges.get_mut(id) {
+            info!(challenge_id = %id, old_name = %config.name, new_name = %new_name, "Renaming challenge");
+            config.name = new_name;
+            self.increment_sequence();
+            return true;
+        }
+
+        false
+    }
+
     /// Add a storage proposal
     pub fn add_storage_proposal(&mut self, proposal: StorageProposal) {
         info!(

crates/rpc-server/src/server.rs

@@ -992,10 +992,21 @@ async fn sudo_challenge_handler(
     }
 
     // Verify signature is from sudo key
-    let message = format!(
-        "sudo:{}:{}:{}",
-        request.action, request.challenge_id, request.timestamp
-    );
+    // For rename action, include the new name in the message
+    let message = if request.action == "rename" {
+        format!(
+            "sudo:{}:{}:{}:{}",
+            request.action,
+            request.challenge_id,
+            request.name.as_deref().unwrap_or(""),
+            request.timestamp
+        )
+    } else {
+        format!(
+            "sudo:{}:{}:{}",
+            request.action, request.challenge_id, request.timestamp
+        )
+    };
 
     let signature = match sp_core::sr25519::Signature::try_from(signature_bytes.as_slice()) {
         Ok(sig) => sig,
@@ -1057,6 +1068,13 @@ async fn sudo_challenge_handler(
             None => Vec::new(),
         };
 
+        // For rename action, use the new name as data
+        let data = if request.action == "rename" {
+            request.name.clone().unwrap_or_default().into_bytes()
+        } else {
+            data
+        };
+
         // Send broadcast command
         let cmd = RpcP2PCommand::BroadcastChallengeUpdate {
             challenge_id,