tendermint_proto/serializers/
bytes.rs

1//! Serialize/deserialize bytes (`Vec<u8>`) type
2
3/// Serialize into hexstring, deserialize from hexstring
4pub mod hexstring {
5    use serde::{Deserialize, Deserializer, Serializer};
6    use subtle_encoding::hex;
7
8    use crate::prelude::*;
9    use crate::serializers::cow_str::CowStr;
10
11    /// Deserialize a hex-encoded string into `Vec<u8>`
12    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
13    where
14        D: Deserializer<'de>,
15        T: From<Vec<u8>>,
16    {
17        let string = Option::<CowStr<'_>>::deserialize(deserializer)?.unwrap_or_default();
18        hex::decode_upper(&string)
19            .or_else(|_| hex::decode(&string))
20            .map(Into::into)
21            .map_err(serde::de::Error::custom)
22    }
23
24    /// Serialize from a byte slice into a hex-encoded string.
25    pub fn serialize<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
26    where
27        S: Serializer,
28        T: AsRef<[u8]>,
29    {
30        let hex_bytes = hex::encode_upper(value.as_ref());
31        let hex_string = String::from_utf8(hex_bytes).map_err(serde::ser::Error::custom)?;
32        serializer.serialize_str(&hex_string)
33    }
34}
35
36/// Serialize into base64string, deserialize from base64string
37pub mod base64string {
38    use serde::{Deserialize, Deserializer, Serializer};
39    use subtle_encoding::base64;
40
41    use crate::prelude::*;
42    use crate::serializers::cow_str::CowStr;
43
44    /// Deserialize base64string into `Vec<u8>`
45    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
46    where
47        D: Deserializer<'de>,
48        Vec<u8>: Into<T>,
49    {
50        let s = Option::<CowStr<'_>>::deserialize(deserializer)?.unwrap_or_default();
51        let v = base64::decode(s).map_err(serde::de::Error::custom)?;
52        Ok(v.into())
53    }
54
55    /// Deserialize base64string into String
56    pub fn deserialize_to_string<'de, D>(deserializer: D) -> Result<String, D::Error>
57    where
58        D: Deserializer<'de>,
59    {
60        let s = Option::<CowStr<'_>>::deserialize(deserializer)?.unwrap_or_default();
61        String::from_utf8(base64::decode(s).map_err(serde::de::Error::custom)?)
62            .map_err(serde::de::Error::custom)
63    }
64
65    /// Serialize from T into base64string
66    pub fn serialize<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
67    where
68        S: Serializer,
69        T: AsRef<[u8]>,
70    {
71        let base64_bytes = base64::encode(value.as_ref());
72        let base64_string = String::from_utf8(base64_bytes).map_err(serde::ser::Error::custom)?;
73        serializer.serialize_str(&base64_string)
74    }
75}
76
77/// Serialize into and deserialize from a sequence of _base64string_.
78pub mod vec_base64string {
79    use serde::{Deserialize, Deserializer, Serializer};
80    use subtle_encoding::base64;
81
82    use crate::prelude::*;
83    use crate::serializers::cow_str::CowStr;
84
85    /// Deserialize array into `Vec<Vec<u8>>`
86    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<Vec<u8>>, D::Error>
87    where
88        D: Deserializer<'de>,
89    {
90        Option::<Vec<CowStr<'_>>>::deserialize(deserializer)?
91            .unwrap_or_default()
92            .into_iter()
93            .map(|s| base64::decode(s).map_err(serde::de::Error::custom))
94            .collect()
95    }
96
97    /// Serialize from `Vec<T>` into `Vec<base64string>`
98    pub fn serialize<S, T>(value: &[T], serializer: S) -> Result<S::Ok, S::Error>
99    where
100        S: Serializer,
101        T: AsRef<[u8]>,
102    {
103        let base64_strings = value
104            .iter()
105            .map(|v| {
106                String::from_utf8(base64::encode(v.as_ref())).map_err(serde::ser::Error::custom)
107            })
108            .collect::<Result<Vec<String>, S::Error>>()?;
109        serializer.collect_seq(base64_strings)
110    }
111}
112
113/// Serialize into and deserialize from an optional _base64string_.
114pub mod option_base64string {
115    use serde::{Deserialize, Deserializer, Serializer};
116    use subtle_encoding::base64;
117
118    use crate::prelude::*;
119    use crate::serializers::cow_str::CowStr;
120
121    /// Deserialize `Option<base64string>` into `Vec<u8>` or null
122    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
123    where
124        D: Deserializer<'de>,
125    {
126        let s = Option::<CowStr<'_>>::deserialize(deserializer)?.unwrap_or_default();
127        base64::decode(s).map_err(serde::de::Error::custom)
128    }
129
130    /// Serialize from `T` into `Option<base64string>`
131    pub fn serialize<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
132    where
133        S: Serializer,
134        T: AsRef<[u8]>,
135    {
136        let base64_bytes = base64::encode(value.as_ref());
137        let base64_string = String::from_utf8(base64_bytes).map_err(serde::ser::Error::custom)?;
138        serializer.serialize_str(&base64_string)
139    }
140}
141
142/// Serialize into string, deserialize from string
143pub mod string {
144    use serde::{Deserialize, Deserializer, Serializer};
145
146    use crate::prelude::*;
147    use crate::serializers::cow_str::CowStr;
148
149    /// Deserialize string into `Vec<u8>`
150    #[allow(dead_code)]
151    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
152    where
153        D: Deserializer<'de>,
154    {
155        let string = Option::<CowStr<'_>>::deserialize(deserializer)?.unwrap_or_default();
156        Ok(string.as_bytes().to_vec())
157    }
158
159    /// Serialize from `T` into string
160    #[allow(dead_code)]
161    pub fn serialize<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
162    where
163        S: Serializer,
164        T: AsRef<[u8]>,
165    {
166        let string =
167            String::from_utf8(value.as_ref().to_vec()).map_err(serde::ser::Error::custom)?;
168        serializer.serialize_str(&string)
169    }
170}
tendermint_proto/serializers/bytes.rs

tendermint_proto/serializers/
bytes.rs
