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

cometbft_proto/serializers/
bytes.rs
