feat(challenge-sdk-wasm): add WASM Guest SDK crate for building challenges (#11)

Introduce the new `platform-challenge-sdk-wasm` crate (`crates/challenge-sdk-wasm/`)
targeting `wasm32-unknown-unknown`. This lightweight, `no_std`-compatible SDK
provides everything challenge developers need to build WASM challenges without
pulling in native dependencies (sled, tokio, axum, etc.).

Core components:

- **Challenge trait & register_challenge! macro** (`src/lib.rs`): Defines the
  `Challenge` trait (evaluate, validate, name, version) and a declarative macro
  that generates `extern "C"` WASM ABI export shims (evaluate, validate,
  get_name, get_version) from a user trait impl, handling serialization via
  bincode and memory allocation for returning data to the host.

- **Host function imports** (`src/host_functions.rs`): Declares extern imports
  from `platform_network` (http_get, http_post, dns_resolve) and
  `platform_storage` (storage_get, storage_set) namespaces matching the
  wasm-runtime-interface contract, with safe Rust wrappers around each.

- **Shared types** (`src/types.rs`): Defines `EvaluationInput` and
  `EvaluationOutput` structs with serde Serialize/Deserialize, mirroring the
  native SDK types without native-only dependencies.

- **Bump allocator** (`src/alloc_impl.rs`): Provides a 1 MiB arena bump
  allocator for WASM linear memory, plus an exported `alloc(size) -> ptr`
  function so the host can allocate guest memory for data passing.

- **Build script update** (`scripts/build-wasm.sh`): Extended to accept an
  optional crate name argument for building challenge crates with this SDK,
  while preserving the existing chain-runtime build as the default.

- **Workspace integration** (`Cargo.toml`, `Cargo.lock`): Added
  `crates/challenge-sdk-wasm` to workspace members and updated the lockfile
  with the new crate and its minimal dependencies (serde, bincode).

Author: echobt

Cargo.lock

@@ -13,6 +13,7 @@ members = [
     "crates/secure-container-runtime",
     "crates/p2p-consensus",
     "crates/wasm-runtime-interface",
+    "crates/challenge-sdk-wasm",
     "bins/validator-node",
     "bins/utils",
     "bins/mock-subtensor",

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "platform-challenge-sdk-wasm"
+version.workspace = true
+edition.workspace = true
+description = "WASM Guest SDK for building challenges targeting wasm32-unknown-unknown"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+serde = { version = "1.0", default-features = false, features = ["derive", "alloc"] }
+bincode = { version = "1.3", default-features = false }

crates/challenge-sdk-wasm/Cargo.toml

@@ -0,0 +1,59 @@
+use core::cell::UnsafeCell;
+
+const ARENA_SIZE: usize = 1024 * 1024; // 1 MiB
+
+struct BumpAllocator {
+    arena: UnsafeCell<[u8; ARENA_SIZE]>,
+    offset: UnsafeCell<usize>,
+}
+
+unsafe impl Sync for BumpAllocator {}
+
+impl BumpAllocator {
+    const fn new() -> Self {
+        Self {
+            arena: UnsafeCell::new([0u8; ARENA_SIZE]),
+            offset: UnsafeCell::new(0),
+        }
+    }
+
+    fn alloc(&self, size: usize, align: usize) -> *mut u8 {
+        unsafe {
+            let offset = &mut *self.offset.get();
+            let aligned = (*offset + align - 1) & !(align - 1);
+            let new_offset = aligned + size;
+            if new_offset > ARENA_SIZE {
+                return core::ptr::null_mut();
+            }
+            *offset = new_offset;
+            let arena = &mut *self.arena.get();
+            arena.as_mut_ptr().add(aligned)
+        }
+    }
+
+    fn reset(&self) {
+        unsafe {
+            *self.offset.get() = 0;
+        }
+    }
+}
+
+static ALLOCATOR: BumpAllocator = BumpAllocator::new();
+
+#[no_mangle]
+pub extern "C" fn alloc(size: i32) -> i32 {
+    let ptr = ALLOCATOR.alloc(size as usize, 8);
+    if ptr.is_null() {
+        0
+    } else {
+        ptr as i32
+    }
+}
+
+pub fn sdk_alloc(size: usize) -> *mut u8 {
+    ALLOCATOR.alloc(size, 8)
+}
+
+pub fn sdk_reset() {
+    ALLOCATOR.reset();
+}

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

@@ -0,0 +1,96 @@
+use alloc::vec;
+use alloc::vec::Vec;
+
+#[link(wasm_import_module = "platform_network")]
+extern "C" {
+    fn http_get(req_ptr: i32, req_len: i32, resp_ptr: i32) -> i32;
+    fn http_post(req_ptr: i32, req_len: i32, resp_ptr: i32, resp_len: i32, extra: i32) -> i32;
+    fn dns_resolve(req_ptr: i32, req_len: i32, resp_ptr: i32) -> i32;
+}
+
+#[link(wasm_import_module = "platform_storage")]
+extern "C" {
+    fn storage_get(key_ptr: i32, key_len: i32, value_ptr: i32) -> i32;
+    fn storage_set(key_ptr: i32, key_len: i32, value_ptr: i32, value_len: i32) -> i32;
+}
+
+pub fn host_http_get(request: &[u8]) -> Result<Vec<u8>, i32> {
+    let mut response_buf = vec![0u8; 65536];
+    let status = unsafe {
+        http_get(
+            request.as_ptr() as i32,
+            request.len() as i32,
+            response_buf.as_mut_ptr() as i32,
+        )
+    };
+    if status < 0 {
+        return Err(status);
+    }
+    response_buf.truncate(status as usize);
+    Ok(response_buf)
+}
+
+pub fn host_http_post(request: &[u8], body: &[u8]) -> Result<Vec<u8>, i32> {
+    let mut response_buf = vec![0u8; 65536];
+    let status = unsafe {
+        http_post(
+            request.as_ptr() as i32,
+            request.len() as i32,
+            response_buf.as_mut_ptr() as i32,
+            response_buf.len() as i32,
+            body.len() as i32,
+        )
+    };
+    if status < 0 {
+        return Err(status);
+    }
+    response_buf.truncate(status as usize);
+    Ok(response_buf)
+}
+
+pub fn host_dns_resolve(request: &[u8]) -> Result<Vec<u8>, i32> {
+    let mut response_buf = vec![0u8; 4096];
+    let status = unsafe {
+        dns_resolve(
+            request.as_ptr() as i32,
+            request.len() as i32,
+            response_buf.as_mut_ptr() as i32,
+        )
+    };
+    if status < 0 {
+        return Err(status);
+    }
+    response_buf.truncate(status as usize);
+    Ok(response_buf)
+}
+
+pub fn host_storage_get(key: &[u8]) -> Result<Vec<u8>, i32> {
+    let mut value_buf = vec![0u8; 65536];
+    let status = unsafe {
+        storage_get(
+            key.as_ptr() as i32,
+            key.len() as i32,
+            value_buf.as_mut_ptr() as i32,
+        )
+    };
+    if status < 0 {
+        return Err(status);
+    }
+    value_buf.truncate(status as usize);
+    Ok(value_buf)
+}
+
+pub fn host_storage_set(key: &[u8], value: &[u8]) -> Result<(), i32> {
+    let status = unsafe {
+        storage_set(
+            key.as_ptr() as i32,
+            key.len() as i32,
+            value.as_ptr() as i32,
+            value.len() as i32,
+        )
+    };
+    if status < 0 {
+        return Err(status);
+    }
+    Ok(())
+}

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

@@ -0,0 +1,123 @@
+#![no_std]
+
+extern crate alloc;
+
+pub mod alloc_impl;
+pub mod host_functions;
+pub mod types;
+
+pub use types::{EvaluationInput, EvaluationOutput};
+
+pub trait Challenge {
+    fn name(&self) -> &'static str;
+    fn version(&self) -> &'static str;
+    fn evaluate(&self, input: EvaluationInput) -> EvaluationOutput;
+    fn validate(&self, input: EvaluationInput) -> bool;
+}
+
+/// Pack a pointer and length into a single i64 value.
+///
+/// The high 32 bits hold the length and the low 32 bits hold the pointer.
+/// The host runtime uses this convention to locate serialized data in WASM
+/// linear memory.
+pub fn pack_ptr_len(ptr: i32, len: i32) -> i64 {
+    ((len as i64) << 32) | ((ptr as u32) as i64)
+}
+
+/// Register a [`Challenge`] implementation and export the required WASM ABI
+/// functions (`evaluate`, `validate`, `get_name`, `get_version`, and `alloc`).
+///
+/// # Usage
+///
+/// ```ignore
+/// struct MyChallenge;
+///
+/// impl platform_challenge_sdk_wasm::Challenge for MyChallenge {
+///     fn name(&self) -> &'static str { "my-challenge" }
+///     fn version(&self) -> &'static str { "0.1.0" }
+///     fn evaluate(&self, input: EvaluationInput) -> EvaluationOutput {
+///         EvaluationOutput::success(100, "ok")
+///     }
+///     fn validate(&self, input: EvaluationInput) -> bool { true }
+/// }
+///
+/// platform_challenge_sdk_wasm::register_challenge!(MyChallenge);
+/// ```
+#[macro_export]
+macro_rules! register_challenge {
+    ($ty:ty) => {
+        static _CHALLENGE: $ty = <$ty as Default>::default();
+
+        #[no_mangle]
+        pub extern "C" fn evaluate(agent_ptr: i32, agent_len: i32) -> i64 {
+            let slice =
+                unsafe { core::slice::from_raw_parts(agent_ptr as *const u8, agent_len as usize) };
+            let input: $crate::EvaluationInput = match bincode::deserialize(slice) {
+                Ok(v) => v,
+                Err(_) => {
+                    return $crate::pack_ptr_len(0, 0);
+                }
+            };
+            let output = <$ty as $crate::Challenge>::evaluate(&_CHALLENGE, input);
+            let encoded = match bincode::serialize(&output) {
+                Ok(v) => v,
+                Err(_) => {
+                    return $crate::pack_ptr_len(0, 0);
+                }
+            };
+            let ptr = $crate::alloc_impl::sdk_alloc(encoded.len());
+            if ptr.is_null() {
+                return $crate::pack_ptr_len(0, 0);
+            }
+            unsafe {
+                core::ptr::copy_nonoverlapping(encoded.as_ptr(), ptr, encoded.len());
+            }
+            $crate::pack_ptr_len(ptr as i32, encoded.len() as i32)
+        }
+
+        #[no_mangle]
+        pub extern "C" fn validate(agent_ptr: i32, agent_len: i32) -> i32 {
+            let slice =
+                unsafe { core::slice::from_raw_parts(agent_ptr as *const u8, agent_len as usize) };
+            let input: $crate::EvaluationInput = match bincode::deserialize(slice) {
+                Ok(v) => v,
+                Err(_) => return 0,
+            };
+            if <$ty as $crate::Challenge>::validate(&_CHALLENGE, input) {
+                1
+            } else {
+                0
+            }
+        }
+
+        #[no_mangle]
+        pub extern "C" fn get_name() -> i32 {
+            let name = <$ty as $crate::Challenge>::name(&_CHALLENGE);
+            let ptr = $crate::alloc_impl::sdk_alloc(4 + name.len());
+            if ptr.is_null() {
+                return 0;
+            }
+            let len_bytes = (name.len() as u32).to_le_bytes();
+            unsafe {
+                core::ptr::copy_nonoverlapping(len_bytes.as_ptr(), ptr, 4);
+                core::ptr::copy_nonoverlapping(name.as_ptr(), ptr.add(4), name.len());
+            }
+            ptr as i32
+        }
+
+        #[no_mangle]
+        pub extern "C" fn get_version() -> i32 {
+            let ver = <$ty as $crate::Challenge>::version(&_CHALLENGE);
+            let ptr = $crate::alloc_impl::sdk_alloc(4 + ver.len());
+            if ptr.is_null() {
+                return 0;
+            }
+            let len_bytes = (ver.len() as u32).to_le_bytes();
+            unsafe {
+                core::ptr::copy_nonoverlapping(len_bytes.as_ptr(), ptr, 4);
+                core::ptr::copy_nonoverlapping(ver.as_ptr(), ptr.add(4), ver.len());
+            }
+            ptr as i32
+        }
+    };
+}

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

@@ -0,0 +1,35 @@
+use alloc::string::String;
+use alloc::vec::Vec;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct EvaluationInput {
+    pub agent_data: Vec<u8>,
+    pub challenge_id: String,
+    pub params: Vec<u8>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct EvaluationOutput {
+    pub score: i64,
+    pub valid: bool,
+    pub message: String,
+}
+
+impl EvaluationOutput {
+    pub fn success(score: i64, message: &str) -> Self {
+        Self {
+            score,
+            valid: true,
+            message: String::from(message),
+        }
+    }
+
+    pub fn failure(message: &str) -> Self {
+        Self {
+            score: 0,
+            valid: false,
+            message: String::from(message),
+        }
+    }
+}