demo no requests error handling

.rustfmt.toml

@@ -1,5 +1,5 @@
 format_strings = true
 wrap_comments = true
-format_doc_comments = true
+format_code_in_doc_comments = true
 merge_imports = false
 max_width = 120

examples/demo.rs

@@ -22,6 +22,7 @@ use hyper::{
 use ocean_rpc::RpcApi;
 use secp256k1::{Message, Secp256k1, SecretKey};
 
+use coordinator::clientchain::get_first_unspent;
 use coordinator::coordinator as coordinator_main;
 use coordinator::ocean::OceanClient;
 
@@ -57,10 +58,14 @@ fn main() {
     });
 
     let genesis_hash = sha256d::Hash::from_hex(&config.clientchain.genesis_hash).unwrap();
-    let request_txid = &client_rpc.get_requests(Some(&genesis_hash)).unwrap()[0].txid;
+    let request = &client_rpc.get_requests(Some(&genesis_hash));
+    if request.as_ref().unwrap().is_empty() {
+        panic!("No active request in client blockchain!")
+    }
+    let request_txid = request.as_ref().unwrap()[0].txid;
     let guardnode_pubkey = "026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3";
     let mut guardnode_txid = genesis_hash; // dummy init
-    for bid in client_rpc.get_request_bids(request_txid).unwrap().unwrap().bids {
+    for bid in client_rpc.get_request_bids(&request_txid).unwrap().unwrap().bids {
         if bid.fee_pub_key.to_string() == guardnode_pubkey {
             guardnode_txid = bid.txid;
             break;
@@ -97,11 +102,13 @@ fn guardnode(
 ) {
     let secp = Secp256k1::new();
     let mut prev_block_count = 0;
-    let unspent = client_rpc.list_unspent(None, None, None, None, Some(&String::from("CHALLENGE"))).unwrap();
-    if unspent.is_empty() {
-        panic!("No challenge issued in client blockchain!")
+    // Get asset hash from unspent list
+    let asset_hash;
+    match get_first_unspent(&client_rpc, &String::from("CHALLENGE")) {
+        Err(_) => panic!("No challenge issued in client blockchain!"),
+        Ok(res) => asset_hash = res.asset,
     }
-    let asset_hash = unspent[0].asset;
+
     loop {
         if let Ok(block_count) = client_rpc.get_block_count() {
             if block_count > prev_block_count {

src/api.rs

@@ -161,7 +161,7 @@ mod tests {
 
     use futures::Future;
 
-    use crate::testing_utils::{gen_dummy_hash,gen_challenge_state,MockStorage};
+    use crate::testing_utils::{gen_challenge_state, gen_dummy_hash, MockStorage};
 
     #[test]
     fn get_request_test() {
@@ -184,8 +184,10 @@ mod tests {
         let params: Params = serde_json::from_str(&s).unwrap();
         let resp = get_request(params, storage.clone());
         assert_eq!(
-            format!(r#"{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}}"#,
-                dummy_hash.to_string()),
+            format!(
+                r#"{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}}"#,
+                dummy_hash.to_string()
+            ),
             resp.wait().unwrap()
         );
     }
@@ -204,8 +206,10 @@ mod tests {
         storage.save_challenge_state(&state).unwrap();
         let resp = get_requests(storage.clone());
         assert_eq!(
-            format!(r#"{{"requests":[{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}}]}}"#,
-                dummy_hash.to_string()),
+            format!(
+                r#"{{"requests":[{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}}]}}"#,
+                dummy_hash.to_string()
+            ),
             resp.wait().unwrap()
         );
 
@@ -214,9 +218,11 @@ mod tests {
         storage.save_challenge_state(&state2).unwrap();
         let resp = get_requests(storage.clone());
         assert_eq!(
-            format!(r#"{{"requests":[{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}},{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}}]}}"#,
+            format!(
+                r#"{{"requests":[{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}},{{"request":{{"txid":"{}","start_blockheight":2,"end_blockheight":5,"genesis_blockhash":"0000000000000000000000000000000000000000000000000000000000000000","fee_percentage":5,"num_tickets":10}},"bids":[{{"txid":"1234567890000000000000000000000000000000000000000000000000000000","pubkey":"026a04ab98d9e4774ad806e302dddeb63bea16b5cb5f223ee77478e861bb583eb3"}}]}}]}}"#,
                 dummy_hash.to_string(),
-                dummy_hash2.to_string()),
+                dummy_hash2.to_string()
+            ),
             resp.wait().unwrap()
         );
     }

src/challenger.rs

@@ -209,7 +209,7 @@ mod tests {
     use std::sync::mpsc::{channel, Receiver, Sender};
 
     use crate::error::Error;
-    use crate::testing_utils::{gen_dummy_hash,MockClientChain,MockService,MockStorage};
+    use crate::testing_utils::{gen_dummy_hash, MockClientChain, MockService, MockStorage};
 
     #[test]
     fn verify_challenge_test() {

src/clientchain.rs

@@ -14,12 +14,12 @@ use crate::ocean::OceanClient;
 
 /// Method that returns the first unspent output for given asset
 /// or an error if the client wallet does not have any unspent/funds
-fn get_first_unspent(client: &OceanClient, asset: &str) -> Result<json::ListUnspentResult> {
+pub fn get_first_unspent(client: &OceanClient, asset: &str) -> Result<json::ListUnspentResult> {
     // Check asset is held by the wallet and return unspent tx
     let unspent = client.list_unspent(None, None, None, None, Some(asset))?;
     if unspent.is_empty() {
         // TODO: custom error for clientchain
-        return Err(Error::from(CError::MissingUnspent))
+        return Err(Error::from(CError::MissingUnspent));
     }
     Ok(unspent[0].clone())
 }

src/listener.rs

@@ -180,7 +180,7 @@ mod tests {
     use bitcoin_hashes::hex::ToHex;
     use secp256k1::SecretKey;
 
-    use crate::testing_utils::{gen_dummy_hash,gen_challenge_state_with_challenge};
+    use crate::testing_utils::{gen_challenge_state_with_challenge, gen_dummy_hash};
 
     #[test]
     fn challengeproof_from_json_test() {
@@ -552,13 +552,16 @@ mod tests {
         assert!(resp_rx.try_recv() == Err(TryRecvError::Empty)); // check receiver empty
 
         // Invalid bid on request body (pubkey does not exist)
-        let data = format!(r#"
+        let data = format!(
+            r#"
         {{
             "txid": "{}",
             "pubkey": "03356190524d52d7e94e1bd43e8f23778e585a4fe1f275e65a06fa5ceedb67d111",
             "hash": "0404040404040404040404040404040404040404040404040404040404040404",
             "sig": "304402201742daea5ec3b7306b9164be862fc1659cc830032180b8b17beffe02645860d602201039eba402d22e630308e6af05da8dd4f05b51b7d672ca5fc9e3b0a57776365c"
-        }}"#, bid_txid);
+        }}"#,
+            bid_txid
+        );
         let request = Request::new(Body::from(data));
         let _ = handle_challengeproof(request, challenge_state.clone(), resp_tx.clone())
             .map(|res| {
@@ -574,13 +577,16 @@ mod tests {
         assert!(resp_rx.try_recv() == Err(TryRecvError::Empty)); // check receiver empty
 
         // Request send for an invalid / out of date challenge hash
-        let data = format!(r#"
+        let data = format!(
+            r#"
         {{
             "txid": "{}",
             "pubkey": "{}",
             "hash": "0404040404040404040404040404040404040404040404040404040404040404",
             "sig": "304402201742daea5ec3b7306b9164be862fc1659cc830032180b8b17beffe02645860d602201039eba402d22e630308e6af05da8dd4f05b51b7d672ca5fc9e3b0a57776365c"
-        }}"#, bid_txid, bid_pubkey);
+        }}"#,
+            bid_txid, bid_pubkey
+        );
         let request = Request::new(Body::from(data));
         let _ = handle_challengeproof(request, challenge_state.clone(), resp_tx.clone())
             .map(|res| {
@@ -596,13 +602,16 @@ mod tests {
         assert!(resp_rx.try_recv() == Err(TryRecvError::Empty)); // check receiver empty
 
         // Request sent an invalid sig for the correct bid and challenge hash
-        let data = format!(r#"
+        let data = format!(
+            r#"
         {{
             "txid": "{}",
             "pubkey": "{}",
             "hash": "{}",
             "sig": "304402201742daea5ec3b7306b9164be862fc1659cc830032180b8b17beffe02645860d602201039eba402d22e630308e6af05da8dd4f05b51b7d672ca5fc9e3b0a57776365c"
-        }}"#, bid_txid, bid_pubkey, chl_hash);
+        }}"#,
+            bid_txid, bid_pubkey, chl_hash
+        );
         let request = Request::new(Body::from(data));
         let _ = handle_challengeproof(request, challenge_state.clone(), resp_tx.clone())
             .map(|res| {

src/testing_utils.rs

@@ -2,18 +2,17 @@
 //!
 //! Colleciton of helper functions used in tests module
 
-
-use bitcoin_hashes::{hex::FromHex, Hash, sha256d};
+use bitcoin_hashes::{hex::FromHex, sha256d, Hash};
+use mongodb::ordered::OrderedDocument;
+use mongodb::Bson;
 use secp256k1::PublicKey;
 use std::cell::RefCell;
 use std::str::FromStr;
-use mongodb::ordered::OrderedDocument;
-use mongodb::Bson;
 
-use crate::challenger::{ChallengeState,ChallengeResponseIds};
-use crate::request::{Bid,BidSet, Request as ServiceRequest};
-use crate::service::Service;
+use crate::challenger::{ChallengeResponseIds, ChallengeState};
 use crate::clientchain::ClientChain;
+use crate::request::{Bid, BidSet, Request as ServiceRequest};
+use crate::service::Service;
 use crate::storage::*;
 
 use crate::error::*;
@@ -46,7 +45,10 @@ pub fn gen_challenge_state(request_hash: &sha256d::Hash) -> ChallengeState {
 }
 
 /// Generate dummy challenge state with specific challenge
-pub fn gen_challenge_state_with_challenge(request_hash: &sha256d::Hash, challenge_hash: &sha256d::Hash) -> ChallengeState {
+pub fn gen_challenge_state_with_challenge(
+    request_hash: &sha256d::Hash,
+    challenge_hash: &sha256d::Hash,
+) -> ChallengeState {
     let request = ServiceRequest {
         txid: sha256d::Hash::from_slice(&[0xff as u8; 32]).unwrap(),
         start_blockheight: 2,