near_openapi_types/
util.rs

1use crate::error;
2
3#[doc = "`CryptoHash`"]
4#[doc = r""]
5#[doc = r" <details><summary>JSON schema</summary>"]
6#[doc = r""]
7#[doc = r" ```json"]
8#[doc = "{"]
9#[doc = "  \"type\": \"string\""]
10#[doc = "}"]
11#[doc = r" ```"]
12#[doc = r" </details>"]
13#[derive(
14    Clone,
15    Debug,
16    Eq,
17    Hash,
18    Ord,
19    PartialEq,
20    PartialOrd,
21)]
22pub struct CryptoHash(pub [u8; 32]);
23impl ::std::ops::Deref for CryptoHash {
24    type Target = [u8; 32];
25    fn deref(&self) -> &[u8; 32] {
26        &self.0
27    }
28}
29impl ::std::convert::From<&CryptoHash> for CryptoHash {
30    fn from(value: &CryptoHash) -> Self {
31        value.clone()
32    }
33}
34impl std::str::FromStr for CryptoHash {
35    type Err = self::error::ConversionError;
36
37    fn from_str(s: &str) -> Result<Self, Self::Err> {
38        let bytes = bs58::decode(s).into_vec()?;
39        Self::try_from(bytes)
40    }
41}
42impl TryFrom<&[u8]> for CryptoHash {
43    type Error = self::error::ConversionError;
44
45    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
46        if bytes.len() != 32 {
47            return Err("length for CryptoHash is not 32".into());
48        }
49        let mut buf = [0; 32];
50        buf.copy_from_slice(bytes);
51        Ok(Self(buf))
52    }
53}
54
55impl TryFrom<Vec<u8>> for CryptoHash {
56    type Error = self::error::ConversionError;
57
58    fn try_from(v: Vec<u8>) -> Result<Self, Self::Error> {
59        <Self as TryFrom<&[u8]>>::try_from(v.as_ref())
60    }
61}
62impl std::fmt::Display for CryptoHash {
63    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
64        ::std::fmt::Display::fmt(&bs58::encode(self.0).into_string(), f)
65    }
66}
67
68impl serde::Serialize for CryptoHash {
69    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
70    where
71        S: serde::Serializer,
72    {
73        serializer.serialize_str(&self.to_string())
74    }
75}
76
77impl<'de> serde::Deserialize<'de> for CryptoHash {
78    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
79    where
80        D: serde::Deserializer<'de>,
81    {
82        let s = String::deserialize(deserializer)?;
83        <Self as std::str::FromStr>::from_str(&s).map_err(serde::de::Error::custom)
84    }
85}