add empty name to NetworkName for no-features build & more cleanups

src/bin/cashierd.rs

@@ -385,12 +385,13 @@ impl Cashierd {
         ))
     }
 
-    fn validate_token_id(network: &NetworkName, token_id: &str) -> Result<Option<String>> {
+    fn validate_token_id(network: &NetworkName, _token_id: &str) -> Result<Option<String>> {
         match network {
             #[cfg(feature = "sol")]
             NetworkName::Solana => {
-                if token_id != "So11111111111111111111111111111111111111112" {
-                    return Ok(Some(token_id.to_string()));
+                use drk::service::sol::SOL_NATIVE_TOKEN_ID;
+                if _token_id != SOL_NATIVE_TOKEN_ID {
+                    return Ok(Some(_token_id.to_string()));
                 }
                 return Ok(None);
             }
@@ -399,6 +400,8 @@ impl Cashierd {
                 // Handle bitcoin address here if needed
                 Ok(None)
             }
+
+            _ => Err(Error::NotSupportedNetwork),
         }
     }
 
@@ -413,8 +416,7 @@ impl Cashierd {
     )> {
         self.cashier_wallet.init_db().await?;
 
-        for (feature_name, chain) in self.features.iter() {
-            let bridge2 = self.bridge.clone();
+        for (feature_name, _chain) in self.features.iter() {
 
             match feature_name {
                 #[cfg(feature = "sol")]
@@ -423,6 +425,8 @@ impl Cashierd {
                     use drk::service::SolClient;
                     use solana_sdk::{signature::Signer, signer::keypair::Keypair};
 
+                    let bridge2 = self.bridge.clone();
+
                     let main_keypair: Keypair;
 
                     let main_keypairs = self.cashier_wallet.get_main_keys(&NetworkName::Solana)?;
@@ -438,7 +442,7 @@ impl Cashierd {
                         main_keypair = deserialize(&main_keypairs[0].0)?;
                     }
 
-                    let sol_client = SolClient::new(serialize(&main_keypair), &chain).await?;
+                    let sol_client = SolClient::new(serialize(&main_keypair), &_chain).await?;
 
                     bridge2.add_clients(NetworkName::Solana, sol_client).await?;
                 }
@@ -448,6 +452,8 @@ impl Cashierd {
                     debug!(target: "CASHIER DAEMON", "Add btc network");
                     use drk::service::btc::{BtcClient, Keypair};
 
+                    let bridge2 = self.bridge.clone();
+
                     let main_keypair: Keypair;
 
                     let main_keypairs = self.cashier_wallet.get_main_keys(&NetworkName::Bitcoin)?;
@@ -463,12 +469,13 @@ impl Cashierd {
                         main_keypair = deserialize(&main_keypairs[0].0)?;
                     }
 
-                    let btc_client = BtcClient::new(serialize(&main_keypair), &chain).await?;
+                    let btc_client = BtcClient::new(serialize(&main_keypair), &_chain).await?;
 
                     bridge2
                         .add_clients(NetworkName::Bitcoin, btc_client)
                         .await?;
                 }
+                _ => {},
             }
         }
 

src/bin/darkfid.rs

@@ -211,11 +211,9 @@ impl Darkfid {
 
         let token_id = match assign_id(&network, &token, self.tokenlist.clone()) {
             Ok(t) => t,
-            Err(_e) => {
+            Err(e) => {
                 debug!(target: "DARKFID", "TOKEN ID IS ERR");
-                // TODO: this should return the relevant drk error
-                // right now it just flattens it into ParseError
-                return JsonResult::Err(jsonerr(ParseError, None, id));
+                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
             }
         };
 
@@ -303,11 +301,9 @@ impl Darkfid {
 
         let token_id = match assign_id(&network, &token, self.tokenlist.clone()) {
             Ok(t) => t,
-            Err(_e) => {
+            Err(e) => {
                 debug!(target: "DARKFID", "TOKEN ID IS ERR");
-                // TODO: this should return the relevant drk error
-                // right now it just flattens it into ParseError
-                return JsonResult::Err(jsonerr(ParseError, None, id));
+                return JsonResult::Err(jsonerr(InternalError, Some(e.to_string()), id));
             }
         };
 

src/error.rs

@@ -118,7 +118,7 @@ impl fmt::Display for Error {
             Error::JsonRpcError(ref err) => write!(f, "JsonRpc Error: {}", err),
             Error::TreeFull => f.write_str("MerkleTree is full"),
             Error::NotSupportedNetwork => {
-                f.write_str("Not supported network inside cashierd config file")
+                f.write_str("Not supported network")
             }
             Error::BridgeError(ref err) => write!(f, "Bridge error: {}", err),
             Error::SerdeJsonError(ref err) => write!(f, "Json serialization error: {}", err),

src/service/bridge.rs

@@ -83,14 +83,18 @@ impl Bridge {
     }
 
     pub async fn listen(self: Arc<Self>) -> Option<Result<TokenNotification>> {
-        debug!(target: "BRIDGE", "Start listening to new notification");
-        self.notifiers
-            .iter()
-            .map(|n| n.recv())
-            .collect::<FuturesUnordered<async_channel::Recv<TokenNotification>>>()
-            .next()
-            .await
-            .map(|o| o.map_err(Error::from))
+        if !self.notifiers.is_empty() {
+            debug!(target: "BRIDGE", "Start listening to new notification");
+            self.notifiers
+                .iter()
+                .map(|n| n.recv())
+                .collect::<FuturesUnordered<async_channel::Recv<TokenNotification>>>()
+                .next()
+                .await
+                .map(|o| o.map_err(Error::from))
+        } else {
+            None
+        }
     }
 
     pub async fn subscribe(

src/util/net_name.rs

@@ -8,6 +8,7 @@ use std::str::FromStr;
 pub enum NetworkName {
     Solana,
     Bitcoin,
+    Empty 
 }
 
 impl std::fmt::Display for NetworkName {
@@ -19,6 +20,9 @@ impl std::fmt::Display for NetworkName {
             Self::Bitcoin => {
                 write!(f, "Bitcoin")
             }
+            Self::Empty => {
+                write!(f, "No Supported Network")
+            }
         }
     }
 }

src/util/parse.rs

@@ -43,40 +43,47 @@ pub fn generate_id(tkn_str: &str, network: &NetworkName) -> Result<jubjub::Fr> {
     Ok(token_id)
 }
 
-pub fn assign_id(network: &str, token: &str, tokenlist: TokenList) -> Result<String> {
+pub fn assign_id(network: &str, _token: &str, _tokenlist: TokenList) -> Result<String> {
     match NetworkName::from_str(network)? {
-        NetworkName::Solana => match token.to_lowercase().as_str() {
+        #[cfg(feature = "sol")]
+        NetworkName::Solana => match _token.to_lowercase().as_str() {
             "solana" | "sol" => {
-                let token_id = "So11111111111111111111111111111111111111112";
+                use crate::service::sol::SOL_NATIVE_TOKEN_ID;
+                let token_id = SOL_NATIVE_TOKEN_ID;
                 Ok(token_id.to_string())
             }
             tkn => {
                 // (== 44) can represent a Solana base58 token mint address
-                let id = if token.len() == 44 {
-                    token.to_string()
+                let id = if _token.len() == 44 {
+                    _token.to_string()
                 } else {
-                    symbol_to_id(tkn, tokenlist)?
+                    symbol_to_id(tkn, _tokenlist)?
                 };
                 Ok(id)
             }
         },
+        #[cfg(feature = "btc")]
         NetworkName::Bitcoin => Err(Error::NetworkParseError),
+        _ => Err(Error::NotSupportedNetwork),
     }
 }
 
-pub fn decimals(network: &str, token: &str, tokenlist: TokenList) -> Result<usize> {
+pub fn decimals(network: &str, _token: &str, _tokenlist: TokenList) -> Result<usize> {
     match NetworkName::from_str(network)? {
-        NetworkName::Solana => match token {
+        #[cfg(feature = "sol")]
+        NetworkName::Solana => match _token {
             "solana" | "sol" => {
                 let decimals = 9;
                 Ok(decimals)
             }
             tkn => {
-                let decimals = tokenlist.search_decimal(tkn)?;
+                let decimals = _tokenlist.search_decimal(tkn)?;
                 Ok(decimals)
             }
         },
+        #[cfg(feature = "btc")]
         NetworkName::Bitcoin => Err(Error::NetworkParseError),
+        _ => Err(Error::NotSupportedNetwork),
     }
 }