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

celestia_core_proto/serializers/
bytes.rs
