fix: address XLS-70 credential review feedback

Author: e-desouza

src/models/ledger/objects/deposit_preauth.rs

@@ -395,6 +395,13 @@ mod tests {
             ),
             previous_txn_lgr_seq: 8,
         };
-        assert!(deposit_preauth.get_errors().is_err());
+        assert_eq!(
+            deposit_preauth.get_errors().unwrap_err(),
+            XRPLModelException::ValueTooLong {
+                field: "authorize_credentials".into(),
+                max: 8,
+                found: 9,
+            }
+        );
     }
 }

src/models/requests/deposit_authorize.rs

@@ -77,6 +77,7 @@ mod tests {
             "rDest11111111111111111111111111111".into(),
             "rSrc111111111111111111111111111111".into(),
             None,
+            None,
             Some(LedgerIndex::Str("validated".into())),
         );
         let serialized = serde_json::to_string(&req).unwrap();

src/models/requests/ledger_entry.rs

@@ -173,6 +173,33 @@ impl<'a> Request<'a> for LedgerEntry<'a> {
     }
 }
 
+impl<'a> Default for LedgerEntry<'a> {
+    fn default() -> Self {
+        Self {
+            common_fields: CommonFields {
+                command: RequestMethod::LedgerEntry,
+                id: None,
+            },
+            account_root: None,
+            binary: None,
+            check: None,
+            credential: None,
+            deposit_preauth: None,
+            directory: None,
+            escrow: None,
+            index: None,
+            ledger_lookup: Some(LookupByLedgerRequest {
+                ledger_hash: None,
+                ledger_index: None,
+            }),
+            offer: None,
+            payment_channel: None,
+            ripple_state: None,
+            ticket: None,
+        }
+    }
+}
+
 impl<'a> LedgerEntry<'a> {
     pub fn new(
         id: Option<Cow<'a, str>>,
@@ -231,26 +258,14 @@ mod test_ledger_entry_errors {
 
     #[test]
     fn test_fields_error() {
-        let ledger_entry = LedgerEntry::new(
-            None,
-            Some("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn".into()),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Offer {
+        let ledger_entry = LedgerEntry {
+            account_root: Some("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn".into()),
+            offer: Some(Offer {
                 account: "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn".into(),
                 seq: 359,
             }),
-            None,
-            None,
-            None,
-        );
+            ..Default::default()
+        };
         let _expected = XRPLModelException::ExpectedOneOf(&[
             "index",
             "account_root",
@@ -272,26 +287,14 @@ mod test_ledger_entry_errors {
 
     #[test]
     fn test_serde() {
-        let req = LedgerEntry::new(
-            None,
-            Some("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn".into()),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Offer {
+        let req = LedgerEntry {
+            account_root: Some("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn".into()),
+            offer: Some(Offer {
                 account: "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn".into(),
                 seq: 359,
             }),
-            None,
-            None,
-            None,
-        );
+            ..Default::default()
+        };
         let serialized = serde_json::to_string(&req).unwrap();
 
         let deserialized: LedgerEntry = serde_json::from_str(&serialized).unwrap();

src/models/transactions/credential_accept.rs

@@ -7,9 +7,9 @@ use crate::models::amount::XRPAmount;
 use crate::models::transactions::CommonFields;
 use crate::models::{
     transactions::{Memo, Signer, Transaction, TransactionType},
-    Model, XRPLModelException, XRPLModelResult,
+    Model, XRPLModelResult,
 };
-use crate::models::{FlagCollection, NoFlags, ValidateCurrencies};
+use crate::models::{FlagCollection, NoFlags};
 
 use super::CommonTransactionBuilder;
 
@@ -18,16 +18,7 @@ use super::CommonTransactionBuilder;
 /// See CredentialAccept:
 /// `<https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0070-credentials>`
 #[skip_serializing_none]
-#[derive(
-    Debug,
-    Default,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    Clone,
-    xrpl_rust_macros::ValidateCurrencies,
-)]
+#[derive(Debug, Default, Serialize, Deserialize, PartialEq, Eq, Clone)]
 #[serde(rename_all = "PascalCase")]
 pub struct CredentialAccept<'a> {
     /// The base fields for all transaction models.
@@ -41,8 +32,7 @@ pub struct CredentialAccept<'a> {
 
 impl<'a> Model for CredentialAccept<'a> {
     fn get_errors(&self) -> XRPLModelResult<()> {
-        self._get_credential_type_error()?;
-        self.validate_currencies()
+        self._get_credential_type_error()
     }
 }
 
@@ -110,22 +100,7 @@ impl<'a> CredentialAccept<'a> {
 
 impl<'a> CredentialAcceptError for CredentialAccept<'a> {
     fn _get_credential_type_error(&self) -> XRPLModelResult<()> {
-        let len = self.credential_type.len();
-        if len == 0 {
-            Err(XRPLModelException::ValueTooShort {
-                field: "credential_type".into(),
-                min: 1,
-                found: 0,
-            })
-        } else if len > 128 {
-            Err(XRPLModelException::ValueTooLong {
-                field: "credential_type".into(),
-                max: 128,
-                found: len,
-            })
-        } else {
-            Ok(())
-        }
+        super::validate_credential_type(&self.credential_type)
     }
 }
 
@@ -136,7 +111,7 @@ pub trait CredentialAcceptError {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::models::Model;
+    use crate::models::{Model, XRPLModelException};
     use alloc::borrow::Cow;
 
     #[test]
@@ -166,47 +141,68 @@ mod tests {
     }
 
     #[test]
-    fn test_credential_type_length_validation() {
+    fn test_credential_type_empty_error() {
         let tx = CredentialAccept {
             common_fields: CommonFields {
                 account: "rSubject11111111111111111111111111".into(),
                 transaction_type: TransactionType::CredentialAccept,
                 ..Default::default()
             },
             issuer: "rIssuer111111111111111111111111111".into(),
-            credential_type: "".into(),
+            credential_type: Cow::from(""),
         };
-        assert!(tx.get_errors().is_err());
+        assert_eq!(
+            tx.get_errors().unwrap_err(),
+            XRPLModelException::ValueTooShort {
+                field: "credential_type".into(),
+                min: 1,
+                found: 0,
+            }
+        );
     }
 
     #[test]
-    fn test_credential_type_empty_error() {
+    fn test_credential_type_too_long_error() {
+        // 129 hex chars exceeds the 128 limit
+        let too_long: Cow<'_, str> = Cow::from("A".repeat(129));
         let tx = CredentialAccept {
             common_fields: CommonFields {
                 account: "rSubject11111111111111111111111111".into(),
                 transaction_type: TransactionType::CredentialAccept,
                 ..Default::default()
             },
             issuer: "rIssuer111111111111111111111111111".into(),
-            credential_type: Cow::from(""),
+            credential_type: too_long,
         };
-        assert!(tx.get_errors().is_err());
+        assert_eq!(
+            tx.get_errors().unwrap_err(),
+            XRPLModelException::ValueTooLong {
+                field: "credential_type".into(),
+                max: 128,
+                found: 129,
+            }
+        );
     }
 
     #[test]
-    fn test_credential_type_too_long_error() {
-        // 129 hex chars exceeds the 128 limit
-        let too_long: Cow<'_, str> = Cow::from("A".repeat(129));
+    fn test_credential_type_non_hex_error() {
         let tx = CredentialAccept {
             common_fields: CommonFields {
                 account: "rSubject11111111111111111111111111".into(),
                 transaction_type: TransactionType::CredentialAccept,
                 ..Default::default()
             },
             issuer: "rIssuer111111111111111111111111111".into(),
-            credential_type: too_long,
+            credential_type: "NOT_HEX".into(),
         };
-        assert!(tx.get_errors().is_err());
+        assert_eq!(
+            tx.get_errors().unwrap_err(),
+            XRPLModelException::InvalidValueFormat {
+                field: "credential_type".into(),
+                format: "hexadecimal".into(),
+                found: "NOT_HEX".into(),
+            }
+        );
     }
 
     #[test]