feat(json_types): implement FromStr for ValidAccountId

near-sdk/src/json_types/account.rs

@@ -1,21 +1,31 @@
 use borsh::{BorshDeserialize, BorshSerialize};
-use serde::Serialize;
-use std::convert::{TryFrom, TryInto};
+use serde::{de, Deserialize, Serialize};
 use std::fmt;
+use std::{convert::TryFrom, str::FromStr};
 
 use crate::env::is_valid_account_id;
 use crate::AccountId;
 
-/// Helper class to validate account ID during serialization and deserializiation
+// TODO: this should probably be a specific error type instead of a string.
+const INVALID_ACCOUNT_ID_MSG: &str = "The account ID is invalid";
+
+/// Helper class to validate account ID during serialization and deserializiation.
+/// This type wraps an [`AccountId`].
+///
+/// # Example
+/// ```
+/// use near_sdk::AccountId;
+/// use near_sdk::json_types::ValidAccountId;
+///
+/// let id: AccountId = "bob.near".to_string();
+/// let validated: ValidAccountId = id.parse().unwrap();
+/// ```
 #[derive(
     Debug, Clone, PartialEq, PartialOrd, Ord, Eq, BorshDeserialize, BorshSerialize, Serialize,
 )]
 pub struct ValidAccountId(AccountId);
 
 impl ValidAccountId {
-    fn is_valid(&self) -> bool {
-        is_valid_account_id(&self.0.as_bytes())
-    }
     pub fn to_string(&self) -> String {
         self.0.clone()
     }
@@ -33,35 +43,47 @@ impl AsRef<AccountId> for ValidAccountId {
     }
 }
 
-impl<'de> serde::Deserialize<'de> for ValidAccountId {
-    fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error>
+impl<'de> Deserialize<'de> for ValidAccountId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, <D as de::Deserializer<'de>>::Error>
     where
-        D: serde::Deserializer<'de>,
+        D: de::Deserializer<'de>,
     {
-        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
-        s.try_into()
-            .map_err(|err: Box<dyn std::error::Error>| serde::de::Error::custom(err.to_string()))
+        let s: String = Deserialize::deserialize(deserializer)?;
+        Self::try_from(s).map_err(de::Error::custom)
     }
 }
 
 impl TryFrom<&str> for ValidAccountId {
     type Error = Box<dyn std::error::Error>;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        Self::try_from(value.to_string())
+        Self::from_str(value)
+    }
+}
+
+fn validate_account_id(id: &str) -> Result<(), Box<dyn std::error::Error>> {
+    if is_valid_account_id(id.as_bytes()) {
+        Ok(())
+    } else {
+        Err(INVALID_ACCOUNT_ID_MSG.into())
     }
 }
 
 impl TryFrom<String> for ValidAccountId {
     type Error = Box<dyn std::error::Error>;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
-        let res = Self(value);
-        if res.is_valid() {
-            Ok(res)
-        } else {
-            Err("The account ID is invalid".into())
-        }
+        validate_account_id(value.as_ref())?;
+        Ok(Self(value))
+    }
+}
+
+impl FromStr for ValidAccountId {
+    type Err = Box<dyn std::error::Error>;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        validate_account_id(value)?;
+        Ok(Self(value.to_string()))
     }
 }
 
@@ -74,7 +96,6 @@ impl From<ValidAccountId> for AccountId {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::convert::TryInto;
 
     #[test]
     fn test_deser() {
@@ -87,7 +108,7 @@ mod tests {
 
     #[test]
     fn test_ser() {
-        let key: ValidAccountId = "alice.near".try_into().unwrap();
+        let key: ValidAccountId = "alice.near".parse().unwrap();
         let actual: String = serde_json::to_string(&key).unwrap();
         assert_eq!(actual, "\"alice.near\"");
     }