fix: resolve all non-result_large_err clippy warnings

- Fix mismatched_lifetime_syntaxes: add explicit '_ to Cow<str>
- Fix deref_addrof: remove unnecessary & on already-reference args
- Fix useless_conversion: remove redundant .into() calls
- Fix len_zero: use .is_empty() instead of .len() > 0
- Fix cmp_owned: compare BigDecimal directly with integer literal
- Fix from_over_into: convert Into impl to From impl for Balance
- Fix is_multiple_of: use .is_multiple_of() instead of modulo
- Fix large_enum_variant: box ServerInfo and ServerState in XRPLResult
- Fix unreachable_code and remove #[allow] directives in asynch/mod.rs

Author: e-desouza

src/asynch/mod.rs

@@ -11,40 +11,33 @@ pub mod transaction;
 #[cfg(feature = "helpers")]
 pub mod wallet;
 
-#[allow(unused_imports)]
-#[allow(clippy::needless_return)]
-#[allow(unused_variables)]
-async fn wait_seconds(seconds: u64) {
-    use core::time::Duration;
-
+async fn wait_seconds(_seconds: u64) {
     #[cfg(feature = "tokio-rt")]
     {
-        tokio::time::sleep(tokio::time::Duration::from_secs(seconds)).await;
-        return;
+        tokio::time::sleep(tokio::time::Duration::from_secs(_seconds)).await;
     }
     #[cfg(feature = "embassy-rt")]
     {
         embassy_time::Timer::after_secs(1).await;
-        return;
     }
     #[cfg(feature = "actix-rt")]
     {
-        actix_rt::time::sleep(Duration::from_secs(seconds)).await;
-        return;
+        use core::time::Duration;
+        actix_rt::time::sleep(Duration::from_secs(_seconds)).await;
     }
     #[cfg(feature = "async-std-rt")]
     {
-        async_std::task::sleep(Duration::from_secs(seconds)).await;
-        return;
+        use core::time::Duration;
+        async_std::task::sleep(Duration::from_secs(_seconds)).await;
     }
     #[cfg(feature = "futures-rt")]
     {
-        futures_timer::Delay::new(Duration::from_secs(seconds)).await;
-        return;
+        use core::time::Duration;
+        futures_timer::Delay::new(Duration::from_secs(_seconds)).await;
     }
     #[cfg(feature = "smol-rt")]
     {
-        smol::Timer::after(Duration::from_secs(seconds)).await;
-        return;
+        use core::time::Duration;
+        smol::Timer::after(Duration::from_secs(_seconds)).await;
     }
 }

src/asynch/transaction/mod.rs

@@ -61,9 +61,9 @@ where
         let serialized_bytes = hex::decode(serialized_for_signing)?;
         let signature = keypairs_sign(&serialized_bytes, &wallet.private_key)?;
         let signer = Signer::new(
-            wallet.classic_address.clone().into(),
-            signature.into(),
-            wallet.public_key.clone().into(),
+            wallet.classic_address.clone(),
+            signature,
+            wallet.public_key.clone(),
         );
         transaction.get_mut_common_fields().signers = Some(vec![signer]);
 

src/cli/mod.rs

@@ -480,15 +480,15 @@ pub fn execute_command(command: &Commands) -> Result<(), CliError> {
             WalletCommands::Validate { address } => {
                 use crate::core::addresscodec::{is_valid_classic_address, is_valid_xaddress};
 
-                let is_valid_classic = is_valid_classic_address(&address);
-                let is_valid_x = is_valid_xaddress(&address);
+                let is_valid_classic = is_valid_classic_address(address);
+                let is_valid_x = is_valid_xaddress(address);
 
                 if is_valid_classic {
                     alloc::println!("Valid classic address: {}", address);
                     Ok(())
                 } else if is_valid_x {
                     use crate::core::addresscodec::xaddress_to_classic_address;
-                    let (classic_address, tag, is_test) = xaddress_to_classic_address(&address)?;
+                    let (classic_address, tag, is_test) = xaddress_to_classic_address(address)?;
                     alloc::println!("Valid X-address: {}", address);
                     alloc::println!("  Classic address: {}", classic_address);
                     alloc::println!("  Destination tag: {:?}", tag);
@@ -786,10 +786,10 @@ pub fn execute_command(command: &Commands) -> Result<(), CliError> {
                 use crate::wallet::Wallet;
 
                 // Create wallet from seed
-                let wallet = Wallet::new(&seed, 0)?;
+                let wallet = Wallet::new(seed, 0)?;
 
                 // Parse the JSON
-                let json_value: Value = serde_json::from_str(&json)?;
+                let json_value: Value = serde_json::from_str(json)?;
 
                 use crate::asynch::transaction::sign;
 

src/core/binarycodec/types/vector256.rs

@@ -66,7 +66,7 @@ impl Serialize for Vector256 {
     where
         S: Serializer,
     {
-        if self.0.len() % _HASH_LENGTH_BYTES != 0 {
+        if !self.0.len().is_multiple_of(_HASH_LENGTH_BYTES) {
             Err(S::Error::custom(XRPLVectorException::InvalidVector256Bytes))
         } else {
             let mut sequence = serializer.serialize_seq(None)?;

src/models/results/mod.rs

@@ -141,8 +141,8 @@ pub enum XRPLResult<'a> {
     PathFind(path_find::PathFind<'a>),
     Random(random::Random<'a>),
     RipplePathFind(ripple_path_find::RipplePathFind<'a>),
-    ServerInfo(server_info::ServerInfo<'a>),
-    ServerState(server_state::ServerState<'a>),
+    ServerInfo(Box<server_info::ServerInfo<'a>>),
+    ServerState(Box<server_state::ServerState<'a>>),
     Submit(submit::Submit<'a>),
     SubmitMultisigned(submit_multisigned::SubmitMultisigned<'a>),
     TransactionEntry(transaction_entry::TransactionEntry<'a>),
@@ -190,8 +190,16 @@ impl_from_result!(no_ripple_check, NoRippleCheck);
 impl_from_result!(path_find, PathFind);
 impl_from_result!(random, Random);
 impl_from_result!(ripple_path_find, RipplePathFind);
-impl_from_result!(server_info, ServerInfo);
-impl_from_result!(server_state, ServerState);
+impl<'a> From<server_info::ServerInfo<'a>> for XRPLResult<'a> {
+    fn from(value: server_info::ServerInfo<'a>) -> Self {
+        XRPLResult::ServerInfo(Box::new(value))
+    }
+}
+impl<'a> From<server_state::ServerState<'a>> for XRPLResult<'a> {
+    fn from(value: server_state::ServerState<'a>) -> Self {
+        XRPLResult::ServerState(Box::new(value))
+    }
+}
 impl_from_result!(submit, Submit);
 impl_from_result!(submit_multisigned, SubmitMultisigned);
 impl_from_result!(transaction_entry, TransactionEntry);
@@ -256,8 +264,34 @@ impl_try_from_result!(no_ripple_check, NoRippleCheck, NoRippleCheck);
 impl_try_from_result!(path_find, PathFind, PathFind);
 impl_try_from_result!(random, Random, Random);
 impl_try_from_result!(ripple_path_find, RipplePathFind, RipplePathFind);
-impl_try_from_result!(server_info, ServerInfo, ServerInfo);
-impl_try_from_result!(server_state, ServerState, ServerState);
+impl<'a> TryFrom<XRPLResult<'a>> for server_info::ServerInfo<'a> {
+    type Error = XRPLModelException;
+
+    fn try_from(result: XRPLResult<'a>) -> XRPLModelResult<Self> {
+        match result {
+            XRPLResult::ServerInfo(value) => Ok(*value),
+            res => Err(XRPLResultException::UnexpectedResultType(
+                "ServerInfo".to_string(),
+                res.get_name(),
+            )
+            .into()),
+        }
+    }
+}
+impl<'a> TryFrom<XRPLResult<'a>> for server_state::ServerState<'a> {
+    type Error = XRPLModelException;
+
+    fn try_from(result: XRPLResult<'a>) -> XRPLModelResult<Self> {
+        match result {
+            XRPLResult::ServerState(value) => Ok(*value),
+            res => Err(XRPLResultException::UnexpectedResultType(
+                "ServerState".to_string(),
+                res.get_name(),
+            )
+            .into()),
+        }
+    }
+}
 impl_try_from_result!(submit, Submit, Submit);
 impl_try_from_result!(submit_multisigned, SubmitMultisigned, SubmitMultisigned);
 impl_try_from_result!(transaction_entry, TransactionEntry, TransactionEntry);
@@ -407,8 +441,40 @@ impl_try_from_response!(path_find, PathFind, PathFind);
 impl_try_from_response!(ping, Ping, Ping);
 impl_try_from_response!(random, Random, Random);
 impl_try_from_response!(ripple_path_find, RipplePathFind, RipplePathFind);
-impl_try_from_response!(server_info, ServerInfo, ServerInfo);
-impl_try_from_response!(server_state, ServerState, ServerState);
+impl<'a> TryFrom<XRPLResponse<'a>> for server_info::ServerInfo<'a> {
+    type Error = XRPLModelException;
+
+    fn try_from(response: XRPLResponse<'a>) -> XRPLModelResult<Self> {
+        match response.result {
+            Some(result) => match result {
+                XRPLResult::ServerInfo(value) => Ok(*value),
+                res => Err(XRPLResultException::UnexpectedResultType(
+                    "ServerInfo".to_string(),
+                    res.get_name(),
+                )
+                .into()),
+            },
+            None => Err(XRPLModelException::MissingField("result".to_string())),
+        }
+    }
+}
+impl<'a> TryFrom<XRPLResponse<'a>> for server_state::ServerState<'a> {
+    type Error = XRPLModelException;
+
+    fn try_from(response: XRPLResponse<'a>) -> XRPLModelResult<Self> {
+        match response.result {
+            Some(result) => match result {
+                XRPLResult::ServerState(value) => Ok(*value),
+                res => Err(XRPLResultException::UnexpectedResultType(
+                    "ServerState".to_string(),
+                    res.get_name(),
+                )
+                .into()),
+            },
+            None => Err(XRPLModelException::MissingField("result".to_string())),
+        }
+    }
+}
 impl_try_from_response!(submit, Submit, Submit);
 impl_try_from_response!(submit_multisigned, SubmitMultisigned, SubmitMultisigned);
 impl_try_from_response!(transaction_entry, TransactionEntry, TransactionEntry);

src/models/transactions/mod.rs

@@ -271,7 +271,7 @@ where
         if let Some(signers) = &self.signers {
             signers
                 .iter()
-                .all(|signer| signer.txn_signature.len() > 0 && signer.signing_pub_key.len() > 0)
+                .all(|signer| !signer.txn_signature.is_empty() && !signer.signing_pub_key.is_empty())
         } else {
             self.txn_signature.is_some() && self.signing_pub_key.is_some()
         }
@@ -602,7 +602,7 @@ where
 
     /// Hashes the Transaction object as the ledger does. Only valid for signed
     /// Transaction objects.
-    fn get_hash(&self) -> XRPLModelResult<Cow<str>>
+    fn get_hash(&self) -> XRPLModelResult<Cow<'_, str>>
     where
         Self: Serialize + DeserializeOwned + Debug + Clone,
     {

src/utils/parse_nftoken_id.rs

@@ -52,7 +52,7 @@ pub fn unscramble_taxon(taxon: u64, token_seq: u64) -> u64 {
 /// |    `---> TransferFee: 1337.0 bps or 13.37%
 /// |
 /// `---> Flags: 11 -> lsfBurnable, lsfOnlyXRP and lsfTransferable
-pub fn parse_nftoken_id(nft_id: Cow<str>) -> XRPLUtilsResult<NFTokenId<'_>> {
+pub fn parse_nftoken_id(nft_id: Cow<'_, str>) -> XRPLUtilsResult<NFTokenId<'_>> {
     const EXPECTED_LEN: usize = 64;
 
     if nft_id.len() != EXPECTED_LEN {

src/utils/txn_parser/get_final_balances.rs

@@ -26,7 +26,7 @@ fn compute_final_balance(node: &NormalizedNode) -> XRPLUtilsResult<Option<BigDec
             value = get_value(&balance.clone().into())?;
         }
     }
-    if value == BigDecimal::from(0) {
+    if value == 0 {
         return Ok(None);
     }
     Ok(Some(value))

src/utils/txn_parser/utils/mod.rs

@@ -36,15 +36,15 @@ impl<'a: 'b, 'b> From<Amount<'a>> for Balance<'b> {
     }
 }
 
-impl<'a> Into<Amount<'a>> for Balance<'a> {
-    fn into(self) -> Amount<'a> {
-        if self.currency == "XRP" {
-            Amount::XRPAmount(self.value.into())
+impl<'a> From<Balance<'a>> for Amount<'a> {
+    fn from(balance: Balance<'a>) -> Self {
+        if balance.currency == "XRP" {
+            Amount::XRPAmount(balance.value.into())
         } else {
             Amount::IssuedCurrencyAmount(crate::models::IssuedCurrencyAmount {
-                currency: self.currency,
-                value: self.value,
-                issuer: self.issuer.unwrap_or("".into()),
+                currency: balance.currency,
+                value: balance.value,
+                issuer: balance.issuer.unwrap_or("".into()),
             })
         }
     }