feat(testing): migrate testing support from spacejam (#12)

* feat(testing): migrate testing support from spacejam

* chore(testing): introduce storage key

* feat(jade): introduce read write host calls

* feat(jade): support operands fetching

* feat(svc): introduce logging in host calls

* chore(testing): migrate tests here

* chore(services): rlib as well for services

* chore(jade): make testing a feature of jade

* chore(cjam): patch cdylib on building services

* chore(sys): adapt new interfaces

* feat(cli): sync the service output dir

* chore(sys): make clippy happy

* chore(testing): get back preimage insertion

* feat(sys): dealloc memory pointers on receiving results

* fix(jade): correct the arguments of is_authozired

* feat(services): make things work again

Author: clearloop

Cargo.lock

@@ -14,7 +14,12 @@ repository = "https://github.com/spacejamapp/jade"
 cjam = { path = "crates/cli" }
 jade = { path = "crates/jade", default-features = false }
 jade-derive = { path = "crates/jade/derive" }
-sys = { path = "crates/sys" }
+spacevm = { path = "crates/sys", package = "spacevm-sys" }
+testing = { path = "crates/testing", package = "jade-testing" }
+
+# services
+nauth = { path = "services/nauth" }
+stoken = { path = "services/stoken" }
 
 # spacejam dependencies
 codec = { package = "serde-jam", version = "0.0.13-pre.1", default-features = false }

Cargo.toml

@@ -161,7 +161,7 @@ pub fn build_pvm_blob(
     }
 
     child
-        .args(["build", "-Z", "build-std=core,alloc"])
+        .args(["rustc", "-Z", "build-std=core,alloc"])
         .arg(profile.to_arg())
         .arg("--target")
         .arg(target_json_path)
@@ -170,7 +170,9 @@ pub fn build_pvm_blob(
             "tiny"
         } else {
             ""
-        }) // Disable stripping for LLVM 19 compatibility
+        })
+        .arg("--lib")
+        .arg("--crate-type=cdylib")
         .env(
             "RUSTFLAGS",
             format!(
@@ -223,12 +225,13 @@ pub fn build_pvm_blob(
         .expect("Failed to link pvm program:");
 
     // Write out a full `.pvm` blob for debugging/inspection.
-    fs::create_dir_all(out_dir).expect("Failed to create jam directory");
-    let output_path_pvm = out_dir.join(format!("{}.pvm", &info.name));
+    let jam_out = out_dir.join("jam");
+    fs::create_dir_all(&jam_out).expect("Failed to create jam directory");
+    let output_path_pvm = jam_out.join(format!("{}.pvm", &info.name));
     fs::write(output_path_pvm, &linked).expect("Error writing resulting binary");
     let name = info.name.clone();
     let metadata = ConventionalMetadata::Info(info).encode().into();
-    let output_file = blob_type.output_file(out_dir, &name);
+    let output_file = blob_type.output_file(&jam_out, &name);
     if !matches!(blob_type, BlobType::CoreVmGuest) {
         let parts = polkavm_linker::ProgramParts::from_bytes(linked.into())
             .expect("failed to deserialize linked PolkaVM program");

crates/cli/src/builder.rs

@@ -1,12 +1,11 @@
 //! `jam build` command
 
-use std::path::PathBuf;
-
 use crate::{
     builder,
     manifest::{ModuleType, Profile},
 };
 use clap::Parser;
+use std::path::PathBuf;
 
 /// CLI utility for building PVM code blobs, particularly services and authorizers.
 #[derive(Parser, Debug, Default)]

crates/cli/src/cmd/build.rs

@@ -19,11 +19,10 @@ pub fn build(package: &str, module: Option<ModuleType>, path: Option<String>) ->
 
     // Build the service
     let target = etc::find_up("target")?;
-    let jam = target.join("jam");
     let current = path
         .map(PathBuf::from)
         .unwrap_or_else(|| env::current_dir().expect("Unable to get current directory"));
-    let binary = jam.join(package).join(format!("{package}.jam"));
+    let binary = target.join("jam").join(format!("{package}.jam"));
     let rebuild = if !binary.exists() {
         true
     } else {
@@ -36,7 +35,7 @@ pub fn build(package: &str, module: Option<ModuleType>, path: Option<String>) ->
         if let Some(module) = module {
             build.module = module;
         }
-        build.target = Some(jam.join(package));
+        build.target = Some(target);
         build.run()?;
     }
 

crates/cli/src/util.rs

@@ -8,12 +8,17 @@ homepage.workspace = true
 repository.workspace = true
 
 [dependencies]
+anyhow.workspace = true
 codec.workspace = true
 jade-derive.workspace = true
+serde.workspace = true
 service.workspace = true
 polkavm-derive.workspace = true
+testing = { workspace = true, optional = true }
 
 [features]
 default = []
-std = ["codec/std", "service/std"]
+logging = []
+testing = ["dep:testing"]
+std = ["anyhow/std", "codec/std", "serde/std", "service/std"]
 tiny = []

crates/jade/Cargo.toml

@@ -22,7 +22,8 @@ pub fn accumulate(_args: TokenStream, input: TokenStream) -> TokenStream {
             let buf = unsafe { core::slice::from_raw_parts(ptr as *const u8, size as usize) };
             let jade::service::vm::AccumulateParams {slot, id, results} =
                 jade::codec::decode(buf).expect("failed to decode accumulate parameters");
-            if let Some(result) = #funame(slot, id, results) {
+            let operands = jade::host::fetch::operands().expect("failed to fetch operands");
+            if let Some(result) = #funame(slot, id, operands) {
                 ((&result).as_ptr() as u64, result.len() as u64)
             } else {
                 (0, 0)

crates/jade/derive/src/accumulate.rs

@@ -20,9 +20,10 @@ pub fn is_authorized(_args: TokenStream, input: TokenStream) -> TokenStream {
             #fun
 
             let buf = unsafe { core::slice::from_raw_parts(ptr as *const u8, size as usize) };
-            let (param, package, core_index): (AuthConfig, WorkPackage, CoreIndex) =
-                jade::codec::decode(buf).expect("failed to decode is_authorized parameters");
-            let result = #funame(param, package, core_index);
+            let core_index: CoreIndex =
+                 jade::codec::decode(buf).inspect_err(|e| jade::error!("decoded is_authorized parameters: {:?}", e))
+                     .expect("failed to decode is_authorized parameters");
+            let result = #funame(core_index);
             ((&result).as_ptr() as u64, result.len() as u64)
         }
     }

crates/jade/derive/src/authorize.rs

@@ -0,0 +1,80 @@
+//! General host calls
+
+use crate::host::import;
+use core::ptr;
+
+/// Get the gas used
+pub fn gas() -> u64 {
+    unsafe { import::gas() }
+}
+
+/// Fetch operations
+pub mod fetch {
+    use super::*;
+    use crate::prelude::{Vec, vec};
+    use anyhow::Result;
+    use service::vm::Operand;
+
+    /// Fetch a value from the storage
+    pub fn operands() -> Result<Vec<Operand>> {
+        let len = unsafe { import::fetch(core::ptr::null_mut(), 0, 0, 14, 0, 0) };
+        let mut target = vec![0; len as usize];
+        let _ = unsafe { import::fetch(target.as_mut_ptr(), 0, len as u64, 14, 0, 0) };
+        codec::decode(target.as_slice()).map_err(Into::into)
+    }
+}
+
+/// Storage operations
+pub mod storage {
+    use super::*;
+    use anyhow::Result;
+
+    /// Read a value from the storage
+    pub fn read<R: serde::de::DeserializeOwned>(key: impl AsRef<[u8]>) -> Option<R> {
+        let len = unsafe {
+            import::read(
+                u64::MAX as _,
+                key.as_ref().as_ptr(),
+                key.as_ref().len() as u64,
+                ptr::null_mut(),
+                0,
+                0,
+            )
+        };
+
+        if len == u64::MAX {
+            return None;
+        } else if len == 0 {
+            return None;
+        }
+
+        let ptr = unsafe {
+            import::read(
+                u64::MAX as _,
+                key.as_ref().as_ptr(),
+                key.as_ref().len() as u64,
+                ptr::null_mut(),
+                0,
+                len,
+            )
+        };
+
+        let value = unsafe { core::slice::from_raw_parts(ptr as _, len as usize) };
+        codec::decode(value).ok()
+    }
+
+    /// Write a value to the storage
+    pub fn write<W: serde::Serialize>(key: impl AsRef<[u8]>, value: &W) -> Result<()> {
+        let value = codec::encode(value)?;
+        unsafe {
+            import::write(
+                key.as_ref().as_ptr(),
+                key.as_ref().len() as u64,
+                value.as_ptr(),
+                value.len() as u64,
+            );
+        };
+
+        Ok(())
+    }
+}

crates/jade/src/host/general.rs

@@ -0,0 +1,41 @@
+//! Imports of host calls
+
+#[polkavm_derive::polkavm_import]
+extern "C" {
+    // NOTE: This is NOT part of the GP.
+    #[polkavm_import(index = 100)]
+    pub fn log(
+        level: u64,
+        target_ptr: *const u8,
+        target_len: u64,
+        text_ptr: *const u8,
+        text_len: u64,
+    );
+
+    /// Get the gas used
+    #[polkavm_import(index = 0)]
+    pub fn gas() -> u64;
+
+    /// Fetch a value from the storage
+    #[polkavm_import(index = 1)]
+    pub fn fetch(buffer: *mut u8, offset: u64, buffer_len: u64, kind: u64, a: u64, b: u64) -> u64;
+
+    /// Read a value from the storage
+    #[polkavm_import(index = 3)]
+    pub fn read(
+        service: u64,
+        key_ptr: *const u8,
+        key_len: u64,
+        out: *mut u8,
+        offset: u64,
+        out_len: u64,
+    ) -> u64;
+
+    /// Write a value to the storage
+    #[polkavm_import(index = 4)]
+    pub fn write(key_ptr: *const u8, key_len: u64, value: *const u8, value_len: u64) -> u64;
+
+    /// Get the info of the service
+    #[polkavm_import(index = 5)]
+    pub fn info(service: u64, service_info_ptr: *mut u8) -> u64;
+}