feat: extend challenge registry wasm metadata

add wasm module metadata with network policy to registry entries
include migration metadata for schema change tracking
add wasm runtime interface dependency for registry

Author: echobt

Cargo.lock

@@ -5,6 +5,7 @@ edition.workspace = true
 description = "Challenge registry and lifecycle management for Platform Network"
 
 [dependencies]
+wasm-runtime-interface = { path = "../wasm-runtime-interface" }
 platform-core = { path = "../core" }
 platform-challenge-sdk = { path = "../challenge-sdk" }
 platform-storage = { path = "../storage" }
@@ -39,4 +40,4 @@ reqwest = { workspace = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }
-tokio-test = { workspace = true }
+tokio-test = { workspace = true }

crates/challenge-registry/Cargo.toml

@@ -26,6 +26,15 @@ pub enum MigrationStatus {
     RolledBack,
 }
 
+/// Migration metadata describing schema changes
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct MigrationMetadata {
+    /// Registry schema version when migration starts
+    pub registry_schema_version: u32,
+    /// Whether WASM module metadata was introduced
+    pub adds_wasm_module_metadata: bool,
+}
+
 /// A single migration step
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MigrationStep {
@@ -41,6 +50,9 @@ pub struct MigrationStep {
     pub reversible: bool,
     /// Estimated duration in seconds
     pub estimated_duration_secs: u64,
+    /// Optional metadata describing schema changes
+    #[serde(default)]
+    pub metadata: Option<MigrationMetadata>,
 }
 
 impl MigrationStep {
@@ -58,6 +70,7 @@ impl MigrationStep {
             to_version: to,
             reversible: true,
             estimated_duration_secs: 60,
+            metadata: None,
         }
     }
 
@@ -72,6 +85,12 @@ impl MigrationStep {
         self.estimated_duration_secs = secs;
         self
     }
+
+    /// Attach migration metadata
+    pub fn with_metadata(mut self, metadata: MigrationMetadata) -> Self {
+        self.metadata = Some(metadata);
+        self
+    }
 }
 
 /// A plan for migrating a challenge between versions
@@ -253,6 +272,10 @@ impl ChallengeMigration {
                     to_version.clone(),
                 )
                 .irreversible()
+                .with_metadata(MigrationMetadata {
+                    registry_schema_version: 2,
+                    adds_wasm_module_metadata: true,
+                })
                 .with_duration(300),
             );
         } else if from_version.minor != to_version.minor {
@@ -266,6 +289,10 @@ impl ChallengeMigration {
                     from_version.clone(),
                     to_version.clone(),
                 )
+                .with_metadata(MigrationMetadata {
+                    registry_schema_version: 2,
+                    adds_wasm_module_metadata: true,
+                })
                 .with_duration(60),
             );
         } else if from_version.patch != to_version.patch {
@@ -279,6 +306,10 @@ impl ChallengeMigration {
                     from_version,
                     to_version,
                 )
+                .with_metadata(MigrationMetadata {
+                    registry_schema_version: 2,
+                    adds_wasm_module_metadata: true,
+                })
                 .with_duration(10),
             );
         }

crates/challenge-registry/src/migration.rs

@@ -11,6 +11,37 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 use tracing::{debug, info, warn};
+use wasm_runtime_interface::NetworkPolicy;
+
+/// WASM module metadata for a challenge
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct WasmModuleMetadata {
+    /// Hash of the WASM module
+    pub module_hash: String,
+    /// Location of the WASM module (URL or path)
+    pub module_location: String,
+    /// Entrypoint function name
+    pub entrypoint: String,
+    /// Network policy for WASM execution
+    #[serde(default)]
+    pub network_policy: NetworkPolicy,
+}
+
+impl WasmModuleMetadata {
+    pub fn new(
+        module_hash: String,
+        module_location: String,
+        entrypoint: String,
+        network_policy: NetworkPolicy,
+    ) -> Self {
+        Self {
+            module_hash,
+            module_location,
+            entrypoint,
+            network_policy,
+        }
+    }
+}
 
 /// Entry for a registered challenge
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -25,6 +56,9 @@ pub struct ChallengeEntry {
     pub docker_image: String,
     /// HTTP endpoint for evaluation
     pub endpoint: Option<String>,
+    /// WASM module metadata
+    #[serde(default)]
+    pub wasm_module: Option<WasmModuleMetadata>,
     /// Current lifecycle state
     pub lifecycle_state: LifecycleState,
     /// Health status
@@ -46,6 +80,7 @@ impl ChallengeEntry {
             version,
             docker_image,
             endpoint: None,
+            wasm_module: None,
             lifecycle_state: LifecycleState::Registered,
             health_status: HealthStatus::Unknown,
             registered_at: now,
@@ -63,6 +98,11 @@ impl ChallengeEntry {
         self.metadata = metadata;
         self
     }
+
+    pub fn with_wasm_module(mut self, wasm_module: WasmModuleMetadata) -> Self {
+        self.wasm_module = Some(wasm_module);
+        self
+    }
 }
 
 /// A registered challenge with its full state