chore: clippy

crates/cashu-sdk/src/client/mod.rs

@@ -28,34 +28,34 @@ pub enum Error {
     InvoiceNotPaid,
     LightingWalletNotResponding(Option<String>),
     /// Parse Url Error
-    UrlParseError(url::ParseError),
+    UrlParse(url::ParseError),
     /// Serde Json error
-    SerdeJsonError(serde_json::Error),
+    SerdeJson(serde_json::Error),
     ///  Min req error
     #[cfg(not(target_arch = "wasm32"))]
-    MinReqError(minreq::Error),
+    MinReq(minreq::Error),
     #[cfg(target_arch = "wasm32")]
-    GlooError(String),
+    Gloo(String),
     /// Custom Error
     Custom(String),
 }
 
 impl From<url::ParseError> for Error {
     fn from(err: url::ParseError) -> Error {
-        Error::UrlParseError(err)
+        Error::UrlParse(err)
     }
 }
 
 impl From<serde_json::Error> for Error {
     fn from(err: serde_json::Error) -> Error {
-        Error::SerdeJsonError(err)
+        Error::SerdeJson(err)
     }
 }
 
 #[cfg(not(target_arch = "wasm32"))]
 impl From<minreq::Error> for Error {
     fn from(err: minreq::Error) -> Error {
-        Error::MinReqError(err)
+        Error::MinReq(err)
     }
 }
 
@@ -72,12 +72,12 @@ impl fmt::Display for Error {
                     mint.clone().unwrap_or("".to_string())
                 )
             }
-            Error::UrlParseError(err) => write!(f, "{}", err),
-            Error::SerdeJsonError(err) => write!(f, "{}", err),
+            Error::UrlParse(err) => write!(f, "{}", err),
+            Error::SerdeJson(err) => write!(f, "{}", err),
             #[cfg(not(target_arch = "wasm32"))]
-            Error::MinReqError(err) => write!(f, "{}", err),
+            Error::MinReq(err) => write!(f, "{}", err),
             #[cfg(target_arch = "wasm32")]
-            Error::GlooError(err) => write!(f, "{}", err),
+            Error::Gloo(err) => write!(f, "{}", err),
             Error::Custom(message) => write!(f, "{}", message),
         }
     }
@@ -159,10 +159,10 @@ impl Client {
         let keys = Request::get(url.as_str())
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let keys: Keys = serde_json::from_str(&keys.to_string())?;
         /*
@@ -211,10 +211,10 @@ impl Client {
         let res = Request::get(url.as_str())
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<nut02::Response, serde_json::Error> =
             serde_json::from_value(res.clone());
@@ -253,10 +253,10 @@ impl Client {
         let res = Request::get(url.as_str())
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<RequestMintResponse, serde_json::Error> =
             serde_json::from_value(res.clone());
@@ -311,13 +311,13 @@ impl Client {
 
         let res = Request::post(url.as_str())
             .json(&request)
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<PostMintResponse, serde_json::Error> =
             serde_json::from_value(res.clone());
@@ -358,13 +358,13 @@ impl Client {
 
         let res = Request::post(url.as_str())
             .json(&request)
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<CheckFeesResponse, serde_json::Error> =
             serde_json::from_value(res.clone());
@@ -425,13 +425,13 @@ impl Client {
 
         let value = Request::post(url.as_str())
             .json(&request)
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<MeltResponse, serde_json::Error> =
             serde_json::from_value(value.clone());
@@ -468,13 +468,13 @@ impl Client {
 
         let res = Request::post(url.as_str())
             .json(&split_request)
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<SplitResponse, serde_json::Error> =
             serde_json::from_value(res.clone());
@@ -523,13 +523,13 @@ impl Client {
 
         let res = Request::post(url.as_str())
             .json(&request)
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<CheckSpendableResponse, serde_json::Error> =
             serde_json::from_value(res.clone());
@@ -561,10 +561,10 @@ impl Client {
         let res = Request::get(url.as_str())
             .send()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?
+            .map_err(|err| Error::Gloo(err.to_string()))?
             .json::<Value>()
             .await
-            .map_err(|err| Error::GlooError(err.to_string()))?;
+            .map_err(|err| Error::Gloo(err.to_string()))?;
 
         let response: Result<MintInfo, serde_json::Error> = serde_json::from_value(res.clone());
 

crates/cashu-sdk/src/mint.rs

@@ -110,7 +110,7 @@ impl Mint {
 
         let mut secrets = Vec::with_capacity(split_request.proofs.len());
         for proof in &split_request.proofs {
-            secrets.push(self.verify_proof(&proof)?);
+            secrets.push(self.verify_proof(proof)?);
             self.spent_secrets.insert(proof.secret.clone());
         }
 

crates/cashu-sdk/src/wallet.rs

@@ -22,9 +22,9 @@ use crate::client::Client;
 pub enum Error {
     /// Insufficaint Funds
     InsufficantFunds,
-    CashuError(cashu::error::wallet::Error),
-    ClientError(crate::client::Error),
-    CustomError(String),
+    Cashu(cashu::error::wallet::Error),
+    Client(crate::client::Error),
+    Custom(String),
 }
 
 impl StdError for Error {}
@@ -33,22 +33,22 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Error::InsufficantFunds => write!(f, "Insufficant Funds"),
-            Error::CashuError(err) => write!(f, "{}", err),
-            Error::ClientError(err) => write!(f, "{}", err),
-            Error::CustomError(err) => write!(f, "{}", err),
+            Error::Cashu(err) => write!(f, "{}", err),
+            Error::Client(err) => write!(f, "{}", err),
+            Error::Custom(err) => write!(f, "{}", err),
         }
     }
 }
 
 impl From<cashu::error::wallet::Error> for Error {
     fn from(err: cashu::error::wallet::Error) -> Self {
-        Self::CashuError(err)
+        Self::Cashu(err)
     }
 }
 
 impl From<crate::client::Error> for Error {
     fn from(err: crate::client::Error) -> Error {
-        Error::ClientError(err)
+        Error::Client(err)
     }
 }
 
@@ -154,9 +154,7 @@ impl Wallet {
                 proofs.push(p);
             } else {
                 warn!("Response missing promises");
-                return Err(Error::CustomError(
-                    "Split response missing promises".to_string(),
-                ));
+                return Err(Error::Custom("Split response missing promises".to_string()));
             }
         }
         Ok(proofs.iter().flatten().cloned().collect())
@@ -267,7 +265,7 @@ impl Wallet {
             keep_proofs = proofs[0..split.len()].to_vec();
             send_proofs = proofs[split.len()..].to_vec();
         } else {
-            return Err(Error::CustomError("Invalid split response".to_string()));
+            return Err(Error::Custom("Invalid split response".to_string()));
         }
 
         // println!("Send Proofs: {:#?}", send_proofs);

crates/cashu/src/nuts/nut06.rs

@@ -86,14 +86,11 @@ impl SplitResponse {
         note = "mint only response with one list of all promises"
     )]
     pub fn change_amount(&self) -> Option<Amount> {
-        match &self.fst {
-            Some(fst) => Some(
-                fst.iter()
-                    .map(|BlindedSignature { amount, .. }| *amount)
-                    .sum(),
-            ),
-            None => None,
-        }
+        self.fst.as_ref().map(|fst| {
+            fst.iter()
+                .map(|BlindedSignature { amount, .. }| *amount)
+                .sum()
+        })
     }
 
     #[deprecated(
@@ -101,25 +98,19 @@ impl SplitResponse {
         note = "mint only response with one list of all promises"
     )]
     pub fn target_amount(&self) -> Option<Amount> {
-        match &self.snd {
-            Some(snd) => Some(
-                snd.iter()
-                    .map(|BlindedSignature { amount, .. }| *amount)
-                    .sum(),
-            ),
-            None => None,
-        }
+        self.snd.as_ref().map(|snd| {
+            snd.iter()
+                .map(|BlindedSignature { amount, .. }| *amount)
+                .sum()
+        })
     }
 
     pub fn promises_amount(&self) -> Option<Amount> {
-        match &self.promises {
-            Some(promises) => Some(
-                promises
-                    .iter()
-                    .map(|BlindedSignature { amount, .. }| *amount)
-                    .sum(),
-            ),
-            None => None,
-        }
+        self.promises.as_ref().map(|promises| {
+            promises
+                .iter()
+                .map(|BlindedSignature { amount, .. }| *amount)
+                .sum()
+        })
     }
 }