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,41 +11,33 @@ pub mod transaction;
 #[cfg(feature = "helpers")]
 pub mod wallet;
 
-#[allow(unused_imports)]
-#[allow(clippy::needless_return)]
-#[allow(unused_variables)]
-#[allow(unreachable_code)]
-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/models/results/mod.rs

@@ -142,8 +142,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>),
@@ -194,8 +194,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);
@@ -319,8 +327,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);
@@ -545,8 +579,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

@@ -269,9 +269,9 @@ where
 {
     pub fn is_signed(&self) -> bool {
         if let Some(signers) = &self.signers {
-            signers.iter().all(|signer| {
-                !signer.txn_signature.is_empty() && !signer.signing_pub_key.is_empty()
-            })
+            signers
+                .iter()
+                .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()
         }

src/utils/txn_parser/utils/mod.rs

@@ -37,7 +37,7 @@ impl<'a: 'b, 'b> From<Amount<'a>> for Balance<'b> {
 }
 
 impl<'a> From<Balance<'a>> for Amount<'a> {
-    fn from(balance: Balance<'a>) -> Amount<'a> {
+    fn from(balance: Balance<'a>) -> Self {
         if balance.currency == "XRP" {
             Amount::XRPAmount(balance.value.into())
         } else {