thread safe errors

Author: jagdeep sidhu

src/bin/main.rs

@@ -1,44 +1,41 @@
-use bitcoin_da_client::*;
+use bitcoin_da_client::SyscoinClient;
+
+type Error = Box<dyn std::error::Error + Send + Sync>;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
+async fn main() -> Result<(), Error> {
     // Create a real RPC client
-    println!("Starting")  ;
+    println!("Starting");
     let rpc_url = "http://127.0.0.1:8370";
     let rpc_user = "u";
     let rpc_password = "p";
     let poda_url = "http://poda.tanenbaum.io/vh/";
     let timeout = Some(std::time::Duration::from_secs(30));
 
-
-    let rpc_client = RealRpcClient::new(rpc_url, rpc_user, rpc_password, timeout)?;
-    println!("Loading wallet") ;
-    rpc_client.create_or_load_wallet("wallet12").await?;
-
-
-    println!("Initializing client") ;
-    let syscoin_client = SyscoinClient::new(
-        "http://127.0.0.1:8370/wallet/wallet12",
-        "u",
-        "p",
+    // Initialize the client
+    let client = SyscoinClient::new(
+        rpc_url,
+        rpc_user,
+        rpc_password,
         poda_url,
         timeout,
     )?;
-
-    println!("checking balance");
-    let balance = syscoin_client.get_balance().await?;
-
-    println!("Balance: {}", balance);
-
-    println!("Sending blob data");
-    let blob_hash = syscoin_client.create_blob(&[1, 2, 3, 4]).await?;
-    println!("Created Blob Hash: {}", blob_hash);
-
-    let blob_data = syscoin_client.get_blob_from_cloud(&blob_hash).await?;
-
-    // TODO: script to get blob from rpc?
-    // TODO: test for resilioence, how long can it be running?
-    println!("Blob Data: {:?}", blob_data);
+    
+    // Create/load wallet
+    println!("Loading wallet");
+    client.create_or_load_wallet("wallet12").await?;
+
+    println!("Checking balance");
+    let balance = client.get_balance().await?;
+    println!("Balance: {balance}");
+
+    println!("Uploading blob data");
+    let blob_hash = client.create_blob(&[1, 2, 3, 4]).await?;
+    println!("Created blob: {blob_hash}");
+
+    println!("Fetching it back (RPC → cloud fallback)");
+    let blob_data = client.get_blob(&blob_hash).await?;
+    println!("Blob data: {blob_data:?}");
 
     Ok(())
 }

src/lib.rs

@@ -12,6 +12,9 @@ const DEFAULT_TIMEOUT_SECS: u64 = 30;
 /// Maximum payload accepted by the Syscoin PoDA endpoint (2 MiB).
 pub const MAX_BLOB_SIZE: usize = 2 * 1024 * 1024;
 
+/// Thread-safe error type
+pub type SyscoinError = Box<dyn Error + Send + Sync + 'static>;
+
 /// Response structure for JSON-RPC calls
 #[derive(Deserialize, Debug)]
 struct JsonRpcResponse<T> {
@@ -23,13 +26,13 @@ struct JsonRpcResponse<T> {
 #[async_trait]
 pub trait RpcClient {
     /// Make a generic RPC call with any method and parameters
-    async fn call(&self, method: &str, params: &[Value]) -> Result<Value, Box<dyn Error>>;
+    async fn call(&self, method: &str, params: &[Value]) -> Result<Value, SyscoinError>;
 
     /// Get wallet balance with optional account and watchonly parameters
-    async fn get_balance(&self, account: Option<&str>, include_watchonly: Option<bool>) -> Result<f64, Box<dyn Error>>;
+    async fn get_balance(&self, account: Option<&str>, include_watchonly: Option<bool>) -> Result<f64, SyscoinError>;
 
     /// Make an HTTP GET request to the specified URL
-    async fn http_get(&self, url: &str) -> Result<Vec<u8>, Box<dyn Error>>;
+    async fn http_get(&self, url: &str) -> Result<Vec<u8>, SyscoinError>;
 }
 
 /// Production implementation of the RPC client for Syscoin
@@ -43,7 +46,7 @@ pub struct RealRpcClient {
 
 impl RealRpcClient {
     /// Create a new RPC client with default timeout
-    pub fn new(rpc_url: &str, rpc_user: &str, rpc_password: &str, timeout: Option<Duration>) -> Result<Self, Box<dyn Error>> {
+    pub fn new(rpc_url: &str, rpc_user: &str, rpc_password: &str, timeout: Option<Duration>) -> Result<Self, SyscoinError> {
         Self::new_with_timeout(rpc_url, rpc_user, rpc_password, timeout)
     }
 
@@ -53,7 +56,7 @@ impl RealRpcClient {
         rpc_user: &str,
         rpc_password: &str,
         timeout: Option<Duration>,
-    ) -> Result<Self, Box<dyn Error>> {
+    ) -> Result<Self, SyscoinError> {
         let timeout = timeout.unwrap_or_else(|| Duration::from_secs(DEFAULT_TIMEOUT_SECS));
 
         let http_client = ClientBuilder::new()
@@ -70,7 +73,7 @@ impl RealRpcClient {
     }
 
     /// Send a JSON-RPC request to the Syscoin node
-    async fn rpc_request(&self, method: &str, params: &[Value]) -> Result<Value, Box<dyn Error>> {
+    async fn rpc_request(&self, method: &str, params: &[Value]) -> Result<Value, SyscoinError> {
         let request_body = json!({
             "jsonrpc": "2.0",
             "id": 1,
@@ -100,7 +103,7 @@ impl RealRpcClient {
     }
 
     /// Create or load a wallet by name
-    pub async fn create_or_load_wallet(&self, wallet_name: &str) -> Result<(), Box<dyn Error>> {
+    pub async fn create_or_load_wallet(&self, wallet_name: &str) -> Result<(), SyscoinError> {
         // First try to load the wallet
         match self.call("loadwallet", &[json!(wallet_name)]).await {
             Ok(_) => return Ok(()),
@@ -115,11 +118,11 @@ impl RealRpcClient {
 
 #[async_trait]
 impl RpcClient for RealRpcClient {
-    async fn call(&self, method: &str, params: &[Value]) -> Result<Value, Box<dyn Error>> {
+    async fn call(&self, method: &str, params: &[Value]) -> Result<Value, SyscoinError> {
         self.rpc_request(method, params).await
     }
 
-    async fn get_balance(&self, account: Option<&str>, include_watchonly: Option<bool>) -> Result<f64, Box<dyn Error>> {
+    async fn get_balance(&self, account: Option<&str>, include_watchonly: Option<bool>) -> Result<f64, SyscoinError> {
         let mut params = Vec::new();
 
         if let Some(acct) = account {
@@ -136,7 +139,7 @@ impl RpcClient for RealRpcClient {
         Ok(balance)
     }
 
-    async fn http_get(&self, url: &str) -> Result<Vec<u8>, Box<dyn Error>> {
+    async fn http_get(&self, url: &str) -> Result<Vec<u8>, SyscoinError> {
         let response = self.http_client.get(url).send().await?;
 
         if !response.status().is_success() {
@@ -160,7 +163,7 @@ impl SyscoinClient {
         rpc_password: &str,
         poda_url: &str,
         timeout: Option<Duration>,
-    ) -> Result<Self, Box<dyn Error>> {
+    ) -> Result<Self, SyscoinError> {
         let rpc_client = RealRpcClient::new_with_timeout(rpc_url, rpc_user, rpc_password, timeout)?;
 
         Ok(Self {
@@ -169,8 +172,13 @@ impl SyscoinClient {
         })
     }
 
+    /// Return the maximum supported blob size
+    pub fn max_blob_size(&self) -> usize {
+        MAX_BLOB_SIZE
+    }
+
     /// Create a blob in BitcoinDA(FKA Poda) storage
-    pub async fn create_blob(&self, data: &[u8]) -> Result<String, Box<dyn Error>> {
+    pub async fn create_blob(&self, data: &[u8]) -> Result<String, SyscoinError> {
         if data.len() > MAX_BLOB_SIZE {
             return Err(format!(
                 "blob size ({}) exceeds maximum allowed ({})",
@@ -193,12 +201,12 @@ impl SyscoinClient {
     }
 
     /// Get wallet balance
-    pub async fn get_balance(&self) -> Result<f64, Box<dyn Error>> {
+    pub async fn get_balance(&self) -> Result<f64, SyscoinError> {
         self.rpc_client.get_balance(None, None).await
     }
 
     /// Fetch a blob; tries RPC first, then falls back to PoDA cloud
-    pub async fn get_blob(&self, blob_id: &str) -> Result<Vec<u8>, Box<dyn Error>> {
+    pub async fn get_blob(&self, blob_id: &str) -> Result<Vec<u8>, SyscoinError> {
         match self.get_blob_from_rpc(blob_id).await {
             Ok(data) => Ok(data),
             Err(e) => {
@@ -209,7 +217,7 @@ impl SyscoinClient {
     }
 
     /// Retrieve blob data from RPC node
-    async fn get_blob_from_rpc(&self, blob_id: &str) -> Result<Vec<u8>, Box<dyn Error>> {
+    async fn get_blob_from_rpc(&self, blob_id: &str) -> Result<Vec<u8>, SyscoinError> {
         // Strip any 0x prefix
         let actual_blob_id = if let Some(stripped) = blob_id.strip_prefix("0x") {
             stripped
@@ -241,20 +249,15 @@ impl SyscoinClient {
     }
 
     /// Retrieve blob data from PODA cloud storage
-    pub async fn get_blob_from_cloud(&self, version_hash: &str) -> Result<Vec<u8>, Box<dyn Error>> {
+    pub async fn get_blob_from_cloud(&self, version_hash: &str) -> Result<Vec<u8>, SyscoinError> {
         let url = format!("{}/blob/{}", self.poda_url, version_hash);
         self.rpc_client.http_get(&url).await
     }
 
     /// Create or load a wallet by name
-    pub async fn create_or_load_wallet(&self, wallet_name: &str) -> Result<(), Box<dyn Error>> {
+    pub async fn create_or_load_wallet(&self, wallet_name: &str) -> Result<(), SyscoinError> {
         self.rpc_client.create_or_load_wallet(wallet_name).await
     }
-
-    /// Return the maximum supported blob size
-    pub fn max_blob_size(&self) -> usize {
-        MAX_BLOB_SIZE
-    }
 }
 
 /// Mock implementation for testing
@@ -266,7 +269,7 @@ pub struct MockRpcClient {
 #[cfg(test)]
 #[async_trait]
 impl RpcClient for MockRpcClient {
-    async fn call(&self, method: &str, _params: &[Value]) -> Result<Value, Box<dyn Error>> {
+    async fn call(&self, method: &str, _params: &[Value]) -> Result<Value, SyscoinError> {
         // Return mock responses based on the method
         match method {
             "getbalance" => Ok(json!(10.5)),
@@ -278,11 +281,11 @@ impl RpcClient for MockRpcClient {
         }
     }
 
-    async fn get_balance(&self, _account: Option<&str>, _include_watchonly: Option<bool>) -> Result<f64, Box<dyn Error>> {
+    async fn get_balance(&self, _account: Option<&str>, _include_watchonly: Option<bool>) -> Result<f64, SyscoinError> {
         Ok(10.5)
     }
 
-    async fn http_get(&self, _url: &str) -> Result<Vec<u8>, Box<dyn Error>> {
+    async fn http_get(&self, _url: &str) -> Result<Vec<u8>, SyscoinError> {
         Ok(b"mock_data".to_vec())
     }
 }

tests/lib_test.rs

@@ -103,28 +103,37 @@ mod tests {
         let mut mock_server = std::thread::spawn(|| {
             Server::new()
         }).join().expect("Failed to create mock server");
+        
         let expected_data = b"retrieved data".to_vec();
         let version_hash = "deadbeef";
 
         // Mock HTTP GET response
         let _m = mock_server
-            .mock("GET", format!("/blob/{}", version_hash).as_str()) // Convert to &str
+            .mock("GET", format!("/blob/{}", version_hash).as_str())
             .with_status(200)
             .with_body(&expected_data)
             .create();
 
         let client = SyscoinClient::new(
-            "http://localhost:8888",
-            "user",
-            "password",
-            &mock_server.url(),
-            None,
-        )
-            .unwrap();
-
-        let result = client.get_blob_from_cloud(version_hash).await;
+            "http://localhost:8888", // RPC URL (won't be used)
+            "user",                   // Username
+            "password",               // Password
+            &mock_server.url(),       // PODA cloud URL
+            None                      // Timeout
+        ).unwrap();
 
-        assert!(result.is_ok());
+        // Use get_blob with a non-existent RPC server to force fallback to cloud
+        // First make sure RPC will fail by mocking it to return an error
+        mock_server
+            .mock("POST", "/")
+            .with_status(500)
+            .with_body("RPC error")
+            .create();
+        
+        // Then call get_blob which should fall back to the cloud endpoint
+        let result = client.get_blob(version_hash).await;
+        
+        assert!(result.is_ok(), "Error: {:?}", result.err());
         assert_eq!(result.unwrap(), expected_data);
     }