add more errors type for jsonrpc & clean up some unwrap calling

src/bin/cashierd.rs

@@ -170,9 +170,34 @@ impl Cashierd {
             return JsonResult::Err(jsonerr(InvalidParams, None, id));
         }
 
-        let network = NetworkName::from_str(args[0].as_str().unwrap()).unwrap();
-        let mut mint_address: String = args[1].as_str().unwrap().to_string();
-        let drk_pub_key = &args[2].as_str().unwrap();
+        let network = &args[0];
+        let mint_address = &args[1];
+        let drk_pub_key = &args[2];
+
+        if network.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+        }
+
+        let network = network.as_str().unwrap();
+
+        let network = match NetworkName::from_str(network) {
+            Ok(d) => d,
+            Err(e) => {
+                return JsonResult::Err(jsonerr(InvalidNetworkParam, Some(e.to_string()), id));
+            }
+        };
+
+        if mint_address.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+        }
+
+        let mut mint_address = mint_address.as_str().unwrap().to_string();
+
+        if drk_pub_key.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+        }
+
+        let drk_pub_key = drk_pub_key.as_str().unwrap();
 
         if !self.features.contains_key(&network.clone()) {
             return JsonResult::Err(jsonerr(
@@ -267,10 +292,36 @@ impl Cashierd {
             return JsonResult::Err(jsonerr(InvalidParams, None, id));
         }
 
+        let network = &args[0];
+        let mint_address = &args[1];
+        let address = &args[2];
+        let amount = &args[3];
+
+        if network.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
+        }
+
         let network = NetworkName::from_str(args[0].as_str().unwrap()).unwrap();
-        let mut mint_address: String = args[1].as_str().unwrap().to_string();
-        let address = &args[2].as_str().unwrap();
-        let _amount = &args[3];
+
+
+        if mint_address.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
+        }
+
+        let mut mint_address = mint_address.as_str().unwrap().to_string();
+
+        if address.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
+        }
+
+        let address = address.as_str().unwrap();
+
+
+        if amount.as_str().is_none() {
+            return JsonResult::Err(jsonerr(InvalidAmountParam, None, id));
+        }
+
+        let _amount = amount.as_str().unwrap();
 
         if !self.features.contains_key(&network.clone()) {
             return JsonResult::Err(jsonerr(
@@ -410,14 +461,15 @@ impl Cashierd {
                             &serialize(&main_keypair.pubkey()),
                             &NetworkName::Bitcoin,
                         )?;
-
                     } else {
                         main_keypair = deserialize(&main_keypairs[0].0)?;
                     }
 
                     let btc_client = BtcClient::new(serialize(&main_keypair), &chain).await?;
 
-                    bridge2.add_clients(NetworkName::Bitcoin, btc_client).await?;
+                    bridge2
+                        .add_clients(NetworkName::Bitcoin, btc_client)
+                        .await?;
                 }
             }
         }
@@ -541,6 +593,6 @@ async fn main() -> Result<()> {
     t1.cancel().await;
     t2.cancel().await;
     t3.cancel().await;
-    
+
     Ok(())
 }

src/bin/darkfid.rs

@@ -14,7 +14,7 @@ use drk::{
     client::Client,
     rpc::{
         jsonrpc::{error as jsonerr, request as jsonreq, response as jsonresp, send_request},
-        jsonrpc::{ErrorCode::*, JsonRequest, JsonResult},
+        jsonrpc::{ErrorCode::*, JsonError, JsonRequest, JsonResult},
         rpcserver::{listen_and_serve, RequestHandler, RpcServerConfig},
     },
     serial::serialize,
@@ -143,7 +143,7 @@ impl Darkfid {
         let symbol = args[0].as_str();
 
         if symbol.is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidSymbolParam, None, id));
         }
         let symbol = symbol.unwrap();
 
@@ -162,7 +162,6 @@ impl Darkfid {
     // --> {""method": "features", "params": []}
     // <-- {"result": { "network": ["btc", "sol"] } }
     async fn features(&self, id: Value, _params: Value) -> JsonResult {
-        // TODO: return a dictionary of features
         let req = jsonreq(json!("features"), json!([]));
         let rep: JsonResult;
         match send_request(&self.config.cashier_rpc_url, json!(req)).await {
@@ -199,13 +198,13 @@ impl Darkfid {
         let token = &args[1];
 
         if token.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
         }
 
         let token = token.as_str().unwrap();
 
         if network.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
         }
 
         let network = network.as_str().unwrap();
@@ -271,26 +270,36 @@ impl Darkfid {
         let amount = &args[3];
 
         if token.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
         }
 
         let token = token.as_str().unwrap();
 
         if network.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidNetworkParam, None, id));
         }
 
         let network = network.as_str().unwrap();
 
         if amount.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidAmountParam, None, id));
         }
 
         let amount = amount.as_str().unwrap();
 
-        // TODO: get rid of these unwraps
-        let decimals = decimals(network, token, self.tokenlist.clone()).unwrap();
-        let amount_in_apo = decode_base10(amount, decimals, true).unwrap();
+        let decimals = match decimals(network, token, self.tokenlist.clone()) {
+            Ok(d) => d,
+            Err(e) => {
+                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
+            }
+        };
+
+        let amount_in_apo = match decode_base10(amount, decimals, true) {
+            Ok(a) => a,
+            Err(e) => {
+                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
+            }
+        };
 
         let token_id = match assign_id(&network, &token, self.tokenlist.clone()) {
             Ok(t) => t,
@@ -342,19 +351,19 @@ impl Darkfid {
         let amount = &args[2];
 
         if token.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidTokenIdParam, None, id));
         }
 
         let _token = address.as_str().unwrap();
 
         if address.as_str().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidAddressParam, None, id));
         }
 
         let _address = address.as_str().unwrap();
 
         if amount.as_f64().is_none() {
-            return JsonResult::Err(jsonerr(InvalidParams, None, id));
+            return JsonResult::Err(jsonerr(InvalidAmountParam, None, id));
         }
 
         let _amount = amount.as_f64().unwrap();

src/rpc/jsonrpc.rs

@@ -16,6 +16,11 @@ pub enum ErrorCode {
     MethodNotFound,
     InvalidParams,
     InternalError,
+    InvalidAmountParam,
+    InvalidNetworkParam,
+    InvalidTokenIdParam,
+    InvalidAddressParam,
+    InvalidSymbolParam,
     ServerError(i64),
 }
 
@@ -27,6 +32,11 @@ impl ErrorCode {
             ErrorCode::MethodNotFound => -32601,
             ErrorCode::InvalidParams => -32602,
             ErrorCode::InternalError => -32603,
+            ErrorCode::InvalidAmountParam => -32604,
+            ErrorCode::InvalidNetworkParam => -32605,
+            ErrorCode::InvalidTokenIdParam => -32606,
+            ErrorCode::InvalidAddressParam => -32607,
+            ErrorCode::InvalidSymbolParam => -32608,
             ErrorCode::ServerError(c) => c,
         }
     }
@@ -38,6 +48,11 @@ impl ErrorCode {
             ErrorCode::MethodNotFound => "Method not found",
             ErrorCode::InvalidParams => "Invalid params",
             ErrorCode::InternalError => "Internal error",
+            ErrorCode::InvalidAmountParam => "Invalid amount param",
+            ErrorCode::InvalidNetworkParam => "Invalid network param",
+            ErrorCode::InvalidTokenIdParam => "Invalid token id param",
+            ErrorCode::InvalidAddressParam => "Invalid address param",
+            ErrorCode::InvalidSymbolParam => "Invalid symbol param",
             ErrorCode::ServerError(_) => "Server error",
         };
         desc.to_string()