fix: reload WASM routes directly from upload bytes in cache invalidator

- Pass wasm_bytes to invalidator callback so routes are reloaded immediately
- Use execute_get_routes_from_bytes instead of loading from storage
- Fixes routes not updating after sudo upload (P2P channel not consumed)

Author: factorydroid

bins/validator-node/src/main.rs

@@ -866,31 +866,46 @@ async fn main() -> Result<()> {
         if let Some(ref executor) = wasm_executor {
             let exec = Arc::clone(executor);
             let cs_for_invalidator = Arc::clone(&chain_state);
-            let invalidator: Arc<dyn Fn(&str) + Send + Sync> = Arc::new(move |challenge_id: &str| {
+            let invalidator: Arc<dyn Fn(&str, &[u8]) + Send + Sync> = Arc::new(move |challenge_id: &str, wasm_bytes: &[u8]| {
                 exec.invalidate_cache(challenge_id);
-                // Reload route definitions from the new WASM module
-                let net_policy = wasm_runtime_interface::NetworkPolicy::default();
-                let sandbox_policy = wasm_runtime_interface::SandboxPolicy::default();
-                if let Ok((bytes, _metrics)) = exec.execute_get_routes(challenge_id, &net_policy, &sandbox_policy) {
-                    if let Ok(routes) = bincode::deserialize::<Vec<platform_challenge_sdk_wasm::WasmRouteDefinition>>(&bytes) {
-                        let route_infos: Vec<platform_core::ChallengeRouteInfo> = routes
-                            .iter()
-                            .map(|r| platform_core::ChallengeRouteInfo {
-                                method: r.method.clone(),
-                                path: r.path.clone(),
-                                description: r.description.clone(),
-                                requires_auth: r.requires_auth,
-                            })
-                            .collect();
-                        if let Ok(cid) = uuid::Uuid::parse_str(challenge_id) {
-                            let mut state = cs_for_invalidator.write();
-                            state.register_challenge_routes(
-                                platform_core::ChallengeId::from_uuid(cid),
-                                route_infos,
-                            );
-                            info!(challenge_id = challenge_id, "Reloaded WASM routes after upload");
+                if wasm_bytes.is_empty() {
+                    return;
+                }
+                // Reload route definitions from the new WASM bytes
+                match exec.execute_get_routes_from_bytes(
+                    challenge_id,
+                    wasm_bytes,
+                    &wasm_runtime_interface::NetworkPolicy::development(),
+                    &wasm_runtime_interface::SandboxPolicy::default(),
+                ) {
+                    Ok((routes_data, _)) => {
+                        if let Ok(routes) = bincode::deserialize::<Vec<platform_challenge_sdk_wasm::WasmRouteDefinition>>(&routes_data) {
+                            let route_infos: Vec<platform_core::ChallengeRouteInfo> = routes
+                                .iter()
+                                .map(|r| platform_core::ChallengeRouteInfo {
+                                    method: r.method.clone(),
+                                    path: r.path.clone(),
+                                    description: r.description.clone(),
+                                    requires_auth: r.requires_auth,
+                                })
+                                .collect();
+                            if let Ok(cid) = uuid::Uuid::parse_str(challenge_id) {
+                                let mut state = cs_for_invalidator.write();
+                                state.register_challenge_routes(
+                                    platform_core::ChallengeId::from_uuid(cid),
+                                    route_infos.clone(),
+                                );
+                                info!(
+                                    challenge_id = challenge_id,
+                                    routes_count = route_infos.len(),
+                                    "Reloaded WASM routes after upload"
+                                );
+                            }
                         }
                     }
+                    Err(e) => {
+                        warn!(challenge_id = challenge_id, error = %e, "Failed to reload routes after upload");
+                    }
                 }
             });
             *rpc_server.rpc_handler().wasm_cache_invalidator.write() = Some(invalidator);

crates/rpc-server/src/jsonrpc.rs

@@ -194,8 +194,9 @@ pub struct RpcHandler {
     pub keypair: Arc<RwLock<Option<platform_core::Keypair>>>,
     /// Real-time weight computation handler
     pub get_weights_handler: Arc<RwLock<Option<GetWeightsHandler>>>,
-    /// Callback to invalidate WASM cache for a challenge (called on wasm_upload)
-    pub wasm_cache_invalidator: Arc<RwLock<Option<Arc<dyn Fn(&str) + Send + Sync>>>>,
+    /// Callback to invalidate WASM cache and reload routes (called on wasm_upload)
+    /// Args: (challenge_id, wasm_bytes)
+    pub wasm_cache_invalidator: Arc<RwLock<Option<Arc<dyn Fn(&str, &[u8]) + Send + Sync>>>>,
 }
 
 impl RpcHandler {

crates/rpc-server/src/server.rs

@@ -1238,10 +1238,14 @@ async fn sudo_challenge_handler(
             "Challenge update broadcast initiated"
         );
 
-        // Invalidate local WASM cache so new module is loaded on next request
+        // Invalidate local WASM cache and reload routes after upload
         if request.action == "wasm_upload" {
             if let Some(ref invalidator) = *handler.wasm_cache_invalidator.read() {
-                invalidator(&request.challenge_id);
+                // Decode wasm bytes again for the invalidator callback
+                let wasm_bytes = request.data.as_ref()
+                    .and_then(|d| base64::Engine::decode(&base64::engine::general_purpose::STANDARD, d).ok())
+                    .unwrap_or_default();
+                invalidator(&request.challenge_id, &wasm_bytes);
                 info!(challenge_id = %request.challenge_id, "WASM cache invalidated after upload");
             }
         }