ethers_solc/artifacts/
serde_helpers.rs

1//! serde helpers
2
3use ethers_core::types::Bytes;
4use serde::{Deserialize, Deserializer};
5
6pub fn deserialize_bytes<'de, D>(d: D) -> Result<Bytes, D::Error>
7where
8    D: Deserializer<'de>,
9{
10    String::deserialize(d)?.parse::<Bytes>().map_err(serde::de::Error::custom)
11}
12
13pub fn deserialize_opt_bytes<'de, D>(d: D) -> Result<Option<Bytes>, D::Error>
14where
15    D: Deserializer<'de>,
16{
17    let value = Option::<String>::deserialize(d)?;
18    value.as_deref().map(str::parse).transpose().map_err(serde::de::Error::custom)
19}
20
21pub fn default_for_null<'de, D, T>(deserializer: D) -> Result<T, D::Error>
22where
23    D: Deserializer<'de>,
24    T: Deserialize<'de> + Default,
25{
26    Ok(Option::<T>::deserialize(deserializer)?.unwrap_or_default())
27}
28
29pub mod json_string_opt {
30    use serde::{
31        de::{self, DeserializeOwned},
32        Deserialize, Deserializer, Serialize, Serializer,
33    };
34
35    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
36    where
37        S: Serializer,
38        T: Serialize,
39    {
40        if let Some(value) = value {
41            value.serialize(serializer)
42        } else {
43            serializer.serialize_none()
44        }
45    }
46
47    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
48    where
49        D: Deserializer<'de>,
50        T: DeserializeOwned,
51    {
52        if let Some(s) = Option::<String>::deserialize(deserializer)? {
53            if s.is_empty() {
54                return Ok(None)
55            }
56            let value = serde_json::Value::String(s);
57            serde_json::from_value(value).map_err(de::Error::custom).map(Some)
58        } else {
59            Ok(None)
60        }
61    }
62}
63
64/// deserializes empty json object `{}` as `None`
65pub mod empty_json_object_opt {
66    use serde::{
67        de::{self, DeserializeOwned},
68        Deserialize, Deserializer, Serialize, Serializer,
69    };
70
71    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
72    where
73        S: Serializer,
74        T: Serialize,
75    {
76        if let Some(value) = value {
77            value.serialize(serializer)
78        } else {
79            let empty = serde_json::Value::Object(Default::default());
80            serde_json::Value::serialize(&empty, serializer)
81        }
82    }
83
84    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
85    where
86        D: Deserializer<'de>,
87        T: DeserializeOwned,
88    {
89        let json = serde_json::Value::deserialize(deserializer)?;
90        if json.is_null() {
91            return Ok(None)
92        }
93        if json.as_object().map(|obj| obj.is_empty()).unwrap_or_default() {
94            return Ok(None)
95        }
96        serde_json::from_value(json).map_err(de::Error::custom).map(Some)
97    }
98}
99
100/// serde support for string
101pub mod string_bytes {
102    use serde::{Deserialize, Deserializer, Serializer};
103
104    pub fn serialize<S>(value: &String, serializer: S) -> Result<S::Ok, S::Error>
105    where
106        S: Serializer,
107    {
108        if value.starts_with("0x") {
109            serializer.serialize_str(value.as_str())
110        } else {
111            serializer.serialize_str(&format!("0x{value}"))
112        }
113    }
114
115    pub fn deserialize<'de, D>(deserializer: D) -> Result<String, D::Error>
116    where
117        D: Deserializer<'de>,
118    {
119        let value = String::deserialize(deserializer)?;
120        if let Some(rem) = value.strip_prefix("0x") {
121            Ok(rem.to_string())
122        } else {
123            Ok(value)
124        }
125    }
126}
127
128pub mod display_from_str_opt {
129    use serde::{de, Deserialize, Deserializer, Serializer};
130    use std::{fmt, str::FromStr};
131
132    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
133    where
134        T: fmt::Display,
135        S: Serializer,
136    {
137        if let Some(value) = value {
138            serializer.collect_str(value)
139        } else {
140            serializer.serialize_none()
141        }
142    }
143
144    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
145    where
146        D: Deserializer<'de>,
147        T: FromStr,
148        T::Err: fmt::Display,
149    {
150        if let Some(s) = Option::<String>::deserialize(deserializer)? {
151            s.parse().map_err(de::Error::custom).map(Some)
152        } else {
153            Ok(None)
154        }
155    }
156}
157
158pub mod display_from_str {
159    use serde::{de, Deserialize, Deserializer, Serializer};
160    use std::{fmt, str::FromStr};
161
162    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
163    where
164        T: fmt::Display,
165        S: Serializer,
166    {
167        serializer.collect_str(value)
168    }
169
170    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
171    where
172        D: Deserializer<'de>,
173        T: FromStr,
174        T::Err: fmt::Display,
175    {
176        String::deserialize(deserializer)?.parse().map_err(de::Error::custom)
177    }
178}
179
180/// (De)serialize vec of tuples as map
181pub mod tuple_vec_map {
182    use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize, Serializer};
183
184    pub fn serialize<K, V, S>(data: &[(K, V)], serializer: S) -> Result<S::Ok, S::Error>
185    where
186        S: Serializer,
187        K: Serialize,
188        V: Serialize,
189    {
190        serializer.collect_map(data.iter().map(|x| (&x.0, &x.1)))
191    }
192
193    pub fn deserialize<'de, K, V, D>(deserializer: D) -> Result<Vec<(K, V)>, D::Error>
194    where
195        D: Deserializer<'de>,
196        K: DeserializeOwned,
197        V: DeserializeOwned,
198    {
199        use serde::de::{MapAccess, Visitor};
200        use std::{fmt, marker::PhantomData};
201
202        struct TupleVecMapVisitor<K, V> {
203            marker: PhantomData<Vec<(K, V)>>,
204        }
205
206        impl<K, V> TupleVecMapVisitor<K, V> {
207            pub fn new() -> Self {
208                TupleVecMapVisitor { marker: PhantomData }
209            }
210        }
211
212        impl<'de, K, V> Visitor<'de> for TupleVecMapVisitor<K, V>
213        where
214            K: Deserialize<'de>,
215            V: Deserialize<'de>,
216        {
217            type Value = Vec<(K, V)>;
218
219            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
220                formatter.write_str("a map")
221            }
222
223            #[inline]
224            fn visit_unit<E>(self) -> Result<Vec<(K, V)>, E> {
225                Ok(Vec::new())
226            }
227
228            #[inline]
229            fn visit_map<T>(self, mut access: T) -> Result<Vec<(K, V)>, T::Error>
230            where
231                T: MapAccess<'de>,
232            {
233                let mut values =
234                    Vec::with_capacity(std::cmp::min(access.size_hint().unwrap_or(0), 4096));
235
236                while let Some((key, value)) = access.next_entry()? {
237                    values.push((key, value));
238                }
239
240                Ok(values)
241            }
242        }
243
244        deserializer.deserialize_map(TupleVecMapVisitor::new())
245    }
246}
ethers_solc/artifacts/serde_helpers.rs

ethers_solc/artifacts/
serde_helpers.rs
