feat(ext): add app-side library for NEAR

Cargo.toml

@@ -15,7 +15,7 @@ members = [
   "./crates/primitives",
   "./crates/runtime",
   "./crates/sdk",
-  "./crates/near-sdk",
+  "./crates/sdk/libs/near",
   "./crates/sdk/macros",
   "./crates/server",
   "./crates/server-primitives",

apps/only-peers/Cargo.toml

@@ -11,4 +11,3 @@ crate-type = ["cdylib"]
 
 [dependencies]
 calimero-sdk = { path = "../../crates/sdk" }
-near-sdk = { path = "../../crates/near-sdk" }

crates/runtime/Cargo.toml

@@ -14,10 +14,9 @@ owo-colors = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 thiserror.workspace = true
-ureq = "2.9.7"
+ureq.workspace = true
 wasmer.workspace = true
 wasmer-types.workspace = true
-borsh = { workspace = true, features = ["derive"] }
 
 [[example]]
 name = "demo"

crates/runtime/src/logic.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::num::NonZeroU64;
 
 use ouroboros::self_referencing;
@@ -309,20 +308,20 @@ impl<'a> VMHostFunctions<'a> {
 
     pub fn fetch(
         &mut self,
-        method_ptr: u64,
-        method_len: u64,
         url_ptr: u64,
         url_len: u64,
+        method_ptr: u64,
+        method_len: u64,
         headers_ptr: u64,
         headers_len: u64,
         body_ptr: u64,
         body_len: u64,
-        out_register_id: u64,
-    ) -> Result<()> {
-        let method = self.get_string(method_ptr, method_len)?;
+        register_id: u64,
+    ) -> Result<u32> {
         let url = self.get_string(url_ptr, url_len)?;
+        let method = self.get_string(method_ptr, method_len)?;
         let headers = self.read_guest_memory(headers_ptr, headers_len)?;
-        let headers: HashMap<String, String> = borsh::from_slice(&headers).unwrap();
+        let headers: Vec<(String, String)> = borsh::from_slice(&headers).unwrap(); // safety: headers are coming from an inner source. Safe to deserialize.
         let body = self.read_guest_memory(body_ptr, body_len)?;
         let mut request = ureq::request(&method, &url);
 
@@ -334,22 +333,20 @@ impl<'a> VMHostFunctions<'a> {
             request.send_bytes(&body)
         } else {
             request.call()
-        }
-        .map_err(|e| HostError::FetchError {
-            url: url.clone(),
-            error: e.to_string(),
-        })?
-        .into_string()
-        .map_err(|e| HostError::FetchError {
-            url,
-            error: e.to_string(),
-        })?;
+        };
 
-        self.with_logic_mut(|logic| {
-            logic
-                .registers
-                .set(&logic.limits, out_register_id, response.into_bytes())
-        })?;
-        Ok(())
+        let (status, data) = match response {
+            Ok(response) => {
+                let mut buffer = vec![];
+                match response.into_reader().read_to_end(&mut buffer) {
+                    Ok(_) => (0, buffer),
+                    Err(_) => (1, "Failed to read the response body.".into()),
+                }
+            }
+            Err(e) => (1, e.to_string().into_bytes()),
+        };
+
+        self.with_logic_mut(|logic| logic.registers.set(&logic.limits, register_id, data))?;
+        Ok(status)
     }
 }

crates/runtime/src/logic/imports.rs

@@ -44,8 +44,18 @@ impl<'a> VMLogic<'a> {
                 register_id: u64,
             ) -> u32;
             fn storage_read(key_ptr: u64, key_len: u64, register_id: u64) -> u32;
-            fn fetch(method_ptr: u64, method_len: u64, url_ptr: u64, url_len: u64, headers_ptr: u64,
-                 headers_len: u64, body_ptr: u64, body_len: u64, out_register_id: u64);
+
+            fn fetch(
+                url_ptr: u64,
+                url_len: u64,
+                method_ptr: u64,
+                method_len: u64,
+                headers_ptr: u64,
+                headers_len: u64,
+                body_ptr: u64,
+                body_len: u64,
+                register_id: u64
+            ) -> u32;
         }
     }
 }

crates/near-sdk/Cargo.toml → crates/sdk/libs/near/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "near-sdk"
+name = "calimero-sdk-near"
 version = "0.1.0"
 authors.workspace = true
 edition.workspace = true
@@ -9,5 +9,5 @@ license.workspace = true
 [dependencies]
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
-calimero-sdk = { path = "../sdk" }
+calimero-sdk = { path = "../../" }
 

crates/sdk/libs/near/src/jsonrpc.rs

@@ -0,0 +1,67 @@
+use calimero_sdk::env;
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "Result")]
+pub enum ResultAlt<T, E> {
+    #[serde(rename = "result")]
+    Ok(T),
+    #[serde(rename = "error")]
+    Err(E),
+}
+
+impl<T, E> From<ResultAlt<T, E>> for Result<T, E> {
+    fn from(result: ResultAlt<T, E>) -> Self {
+        match result {
+            ResultAlt::Ok(value) => Ok(value),
+            ResultAlt::Err(err) => Err(err),
+        }
+    }
+}
+
+pub(crate) struct Client {
+    url: String,
+}
+
+impl Client {
+    pub fn new(url: String) -> Self {
+        Self { url }
+    }
+
+    pub fn call<T: DeserializeOwned, E: DeserializeOwned>(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+    ) -> Result<Response<T, E>, String> {
+        let headers = [("Content-Type", "application/json")];
+
+        let body = serde_json::to_vec(&serde_json::json!({
+            "jsonrpc": "2.0",
+            "id": "1",
+            "method": method,
+            "params": params,
+        }))
+        .map_err(|err| format!("Cannot serialize request: {:?}", err))?;
+
+        let response = unsafe { env::ext::fetch(&self.url, "POST", &headers, &body) }?;
+        let response = String::from_utf8(response).map_err(|e| e.to_string())?;
+        serde_json::from_str::<Response<T, E>>(&response).map_err(|e| e.to_string())
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Response<T: DeserializeOwned, E: DeserializeOwned> {
+    pub jsonrpc: Option<String>,
+    pub id: String,
+
+    #[serde(with = "ResultAlt", flatten)]
+    pub data: Result<T, RpcError<E>>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct RpcError<E> {
+    pub code: i32,
+    pub message: String,
+    pub data: Option<E>,
+}