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

Cargo.toml

@@ -53,6 +53,7 @@ multiaddr = "0.18.1"
 near-jsonrpc-client = "0.8.0"
 near-jsonrpc-primitives = "0.20.0"
 near-primitives = "0.20.0"
+near-account-id = "1.0.0"
 near-sdk = "5.0.0"
 near-workspaces = "0.10.0"
 ouroboros = "0.18.3"

apps/only-peers/src/lib.rs

@@ -43,17 +43,6 @@ pub enum Event<'a> {
 
 #[app::logic]
 impl OnlyPeers {
-    pub fn foo(&mut self) -> String {
-        let client = calimero_sdk_near::Client::testnet();
-        match client.view_account(
-            "nearkat.testnet",
-            calimero_sdk_near::types::BlockId::Height(166710735),
-        ) {
-            Ok(r) => format!("{}", r.amount),
-            Err(e) => e,
-        }
-    }
-
     pub fn post(&self, id: usize) -> Option<&Post> {
         env::log(&format!("Getting post with id: {:?}", id));
 

crates/runtime/examples/fetch.rs

@@ -24,7 +24,7 @@ fn main() -> eyre::Result<()> {
     let cx = logic::VMContext {
         input: serde_json::to_vec(&json!({}))?,
     };
-    let get_outcome = run(file, "foo", cx, &mut storage, &limits)?;
+    let get_outcome = run(file, "fetch", cx, &mut storage, &limits)?;
     let returns = String::from_utf8(get_outcome.returns.unwrap().unwrap()).unwrap();
     println!("{returns}");
 

crates/runtime/src/errors.rs

@@ -86,8 +86,6 @@ pub enum HostError {
     EventKindSizeOverflow,
     #[error("event data size overflow")]
     EventDataSizeOverflow,
-    #[error("failed to fetch data from {url} with error: {error}")]
-    FetchError { url: String, error: String },
 }
 
 #[derive(Debug, Serialize)]

crates/sdk/libs/near/Cargo.toml

@@ -7,9 +7,11 @@ repository.workspace = true
 license.workspace = true
 
 [dependencies]
+near-account-id = { workspace = true, features = ["serde"]}
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 serde_with = {workspace = true, features = ["base64"]}
+thiserror.workspace = true
 
 calimero-sdk = { path = "../../" }
 calimero-primitives = { path = "../../../primitives" }

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

@@ -0,0 +1,13 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum NearLibError {
+    #[error(transparent)]
+    JsonError(#[from] serde_json::Error),
+
+    #[error(transparent)]
+    IoError(#[from] std::io::Error),
+
+    #[error("Failed to fetch: {0}")]
+    FetchError(String),
+}

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

@@ -2,6 +2,8 @@ use calimero_sdk::env;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
+use crate::error::NearLibError;
+
 pub(crate) struct Client {
     url: String,
     id: std::cell::RefCell<u64>,
@@ -19,29 +21,28 @@ impl Client {
         &self,
         method: &str,
         params: P,
-    ) -> Result<Response<T, E>, String> {
+    ) -> Result<Response<T, E>, NearLibError> {
         let headers = [("Content-Type", "application/json")];
 
         *self.id.borrow_mut() += 1;
         let body = serde_json::to_vec(&Request {
             jsonrpc: "2.0",
-            id: self.id.borrow().to_string(),
-            method: method.to_string(),
+            id: &*self.id.borrow().to_string(),
+            method,
             params,
-        })
-        .map_err(|err| format!("Cannot serialize request: {:?}", err))?;
+        })?;
 
-        let response = unsafe { env::ext::fetch(&self.url, "POST", &headers, &body) }?;
-        serde_json::from_slice::<Response<T, E>>(&response)
-            .map_err(|e| format!("Failed to parse response: {}", e.to_string(),))
+        let response = unsafe { env::ext::fetch(&self.url, "POST", &headers, &body) }
+            .map_err(NearLibError::FetchError)?;
+        Ok(serde_json::from_slice::<Response<T, E>>(&response)?)
     }
 }
 
 #[derive(Debug, Clone, Serialize)]
-pub struct Request<P: Serialize> {
-    pub jsonrpc: &'static str,
-    pub id: String,
-    pub method: String,
+struct Request<'a, P: Serialize> {
+    pub jsonrpc: &'a str,
+    pub id: &'a str,
+    pub method: &'a str,
 
     pub params: P,
 }

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

@@ -1,8 +1,7 @@
+use error::NearLibError;
 use jsonrpc::Response;
-use query::{QueryResponseKind, RpcQueryRequest};
-use types::{BlockId, FunctionArgs, StoreKey};
-use views::QueryRequest;
 
+pub mod error;
 mod jsonrpc;
 pub mod query;
 pub mod types;
@@ -12,6 +11,13 @@ pub struct Client {
     client: jsonrpc::Client,
 }
 
+pub trait RpcMethod {
+    type Response: serde::de::DeserializeOwned;
+
+    fn method_name(&self) -> &str;
+    fn params(&self) -> Result<serde_json::Value, std::io::Error>;
+}
+
 impl Client {
     pub fn testnet() -> Self {
         Self {
@@ -25,142 +31,10 @@ impl Client {
         }
     }
 
-    pub fn view_account(
-        &self,
-        account_id: &str,
-        block_id: BlockId,
-    ) -> Result<views::AccountView, String> {
-        let request = RpcQueryRequest {
-            block_id,
-            request: QueryRequest::ViewAccount {
-                account_id: account_id.to_string(),
-            },
-        };
-        let response: Response<query::RpcQueryResponse, String> =
-            self.client.call("query", request)?;
-
-        match response.data {
-            Ok(r) => {
-                if let QueryResponseKind::ViewAccount(va) = r.kind {
-                    return Ok(va);
-                }
-                return Err("Unexpected response returned.".to_string());
-            }
-            Err(e) => Err(format!("Error: {}, Code: {}", e.message, e.code,)),
-        }
-    }
-
-    pub fn view_code(
-        &self,
-        account_id: &str,
-        block_id: BlockId,
-    ) -> Result<views::ContractCodeView, String> {
-        let request = RpcQueryRequest {
-            block_id,
-            request: QueryRequest::ViewCode {
-                account_id: account_id.to_string(),
-            },
-        };
-
-        let response: Response<query::RpcQueryResponse, String> =
-            self.client.call("query", request)?;
-
-        match response.data {
-            Ok(r) => {
-                if let QueryResponseKind::ViewCode(vc) = r.kind {
-                    return Ok(vc);
-                }
-                return Err("Unexpected response returned.".to_string());
-            }
-            Err(e) => Err(format!("Error: {}, Code: {}", e.message, e.code,)),
-        }
-    }
-
-    pub fn view_state(
-        &self,
-        account_id: &str,
-        prefix: StoreKey,
-        include_proof: bool,
-        block_id: BlockId,
-    ) -> Result<views::ViewStateResult, String> {
-        let request = RpcQueryRequest {
-            block_id,
-            request: QueryRequest::ViewState {
-                account_id: account_id.to_string(),
-                prefix,
-                include_proof,
-            },
-        };
-
-        let response: Response<query::RpcQueryResponse, String> =
-            self.client.call("query", request)?;
-
-        match response.data {
-            Ok(r) => {
-                if let QueryResponseKind::ViewState(vs) = r.kind {
-                    return Ok(vs);
-                }
-                return Err("Unexpected response returned.".to_string());
-            }
-            Err(e) => Err(format!("Error: {}, Code: {}", e.message, e.code,)),
-        }
-    }
-
-    pub fn view_access_key(
-        &self,
-        account_id: &str,
-        public_key: &str,
-        block_id: BlockId,
-    ) -> Result<views::ViewStateResult, String> {
-        let request = RpcQueryRequest {
-            block_id,
-            request: QueryRequest::ViewAccessKey {
-                account_id: account_id.to_string(),
-                public_key: public_key.to_string(),
-            },
-        };
-
-        let response: Response<query::RpcQueryResponse, String> =
-            self.client.call("query", request)?;
-
-        match response.data {
-            Ok(r) => {
-                if let QueryResponseKind::ViewState(vs) = r.kind {
-                    return Ok(vs);
-                }
-                return Err("Unexpected response returned.".to_string());
-            }
-            Err(e) => Err(format!("Error: {}, Code: {}", e.message, e.code,)),
-        }
-    }
-
-    pub fn call_function(
-        &self,
-        account_id: &str,
-        method_name: &str,
-        args: FunctionArgs,
-        block_id: BlockId,
-    ) -> Result<views::CallResult, String> {
-        let request = RpcQueryRequest {
-            block_id,
-            request: QueryRequest::CallFunction {
-                account_id: account_id.to_string(),
-                method_name: method_name.to_string(),
-                args,
-            },
-        };
-
-        let response: Response<query::RpcQueryResponse, String> =
-            self.client.call("query", request)?;
-
-        match response.data {
-            Ok(r) => {
-                if let QueryResponseKind::CallResult(cr) = r.kind {
-                    return Ok(cr);
-                }
-                return Err("Unexpected response returned.".to_string());
-            }
-            Err(e) => Err(format!("Error: {}, Code: {}", e.message, e.code,)),
-        }
+    pub fn call<M>(&self, method: M) -> Result<Response<M::Response, String>, NearLibError>
+    where
+        M: RpcMethod,
+    {
+        self.client.call(method.method_name(), &method.params()?)
     }
 }

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

@@ -1,8 +1,11 @@
+use serde_json::json;
+
 use crate::types::{BlockHash, BlockHeight, BlockId};
 use crate::views::{
     AccessKeyList, AccessKeyView, AccountView, CallResult, ContractCodeView, QueryRequest,
     ViewStateResult,
 };
+use crate::RpcMethod;
 
 #[derive(serde::Serialize, Debug)]
 pub struct RpcQueryRequest {
@@ -29,3 +32,15 @@ pub enum QueryResponseKind {
     AccessKeyList(AccessKeyList),
     CallResult(CallResult),
 }
+
+impl RpcMethod for RpcQueryRequest {
+    type Response = RpcQueryResponse;
+
+    fn method_name(&self) -> &str {
+        "query"
+    }
+
+    fn params(&self) -> Result<serde_json::Value, std::io::Error> {
+        Ok(json!(self))
+    }
+}

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

@@ -2,10 +2,11 @@ use serde_with::base64::Base64;
 use serde_with::serde_as;
 
 pub type BlockHeight = u64;
-pub type BlockHash = String;
-pub type AccountId = String;
+pub type BlockHash = calimero_primitives::hash::Hash;
+pub type AccountId = near_account_id::AccountId;
 pub type StorageUsage = u64;
 pub type Nonce = u64;
+pub type Balance = u128;
 
 #[derive(Debug, Clone, serde::Serialize)]
 #[serde(untagged)]