openzeppelin_relayer/utils/serde/
u128_deserializer.rs

1//! Deserialization utilities for u128 values
2//!
3//! This module provides a custom deserializer for u128 values.
4
5use std::fmt;
6
7use serde::{de, Deserialize, Deserializer, Serializer};
8
9use super::deserialize_u64;
10
11#[derive(Debug)]
12struct U128Visitor;
13
14impl de::Visitor<'_> for U128Visitor {
15    type Value = u128;
16
17    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
18        formatter.write_str("a string containing a u128 number or a u128 integer")
19    }
20
21    // Handle string inputs like "340282366920938463463374607431768211455"
22    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
23    where
24        E: de::Error,
25    {
26        value.parse::<u128>().map_err(de::Error::custom)
27    }
28
29    // Handle u64 inputs
30    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
31    where
32        E: de::Error,
33    {
34        Ok(value as u128)
35    }
36
37    // Handle i64 inputs
38    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
39    where
40        E: de::Error,
41    {
42        if value < 0 {
43            Err(de::Error::custom(
44                "negative value cannot be converted to u128",
45            ))
46        } else {
47            Ok(value as u128)
48        }
49    }
50}
51
52pub fn deserialize_u128<'de, D>(deserializer: D) -> Result<u128, D::Error>
53where
54    D: Deserializer<'de>,
55{
56    deserializer.deserialize_any(U128Visitor)
57}
58
59// Deserialize optional u128
60pub fn deserialize_optional_u128<'de, D>(deserializer: D) -> Result<Option<u128>, D::Error>
61where
62    D: Deserializer<'de>,
63{
64    #[derive(Deserialize)]
65    struct Helper(#[serde(deserialize_with = "deserialize_u128")] u128);
66
67    let helper = Option::<Helper>::deserialize(deserializer)?;
68    Ok(helper.map(|Helper(value)| value))
69}
70
71// Serialize u128 as string
72pub fn serialize_u128<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
73where
74    S: Serializer,
75{
76    serializer.serialize_str(&value.to_string())
77}
78
79// Serialize optional u128 as string
80pub fn serialize_optional_u128<S>(value: &Option<u128>, serializer: S) -> Result<S::Ok, S::Error>
81where
82    S: Serializer,
83{
84    match value {
85        Some(v) => serializer.serialize_some(&v.to_string()),
86        None => serializer.serialize_none(),
87    }
88}
89
90pub fn serialize_optional_u128_as_number<S>(
91    value: &Option<u128>,
92    serializer: S,
93) -> Result<S::Ok, S::Error>
94where
95    S: Serializer,
96{
97    match value {
98        Some(v) => serializer.serialize_some(&v),
99        None => serializer.serialize_none(),
100    }
101}
102
103/// Deserialize optional u128 from number
104pub fn deserialize_optional_u128_as_number<'de, D>(
105    deserializer: D,
106) -> Result<Option<u128>, D::Error>
107where
108    D: Deserializer<'de>,
109{
110    let value: Option<u128> = Option::deserialize(deserializer)?;
111    Ok(value)
112}
113
114/// Serialize u128 as number (non-optional)
115pub fn serialize_u128_as_number<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
116where
117    S: Serializer,
118{
119    serializer.serialize_u128(*value)
120}
121
122/// Deserialize u128 from number (non-optional)
123pub fn deserialize_u128_as_number<'de, D>(deserializer: D) -> Result<u128, D::Error>
124where
125    D: Deserializer<'de>,
126{
127    u128::deserialize(deserializer)
128}
129
130// Deserialize optional u64
131pub fn deserialize_optional_u64<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
132where
133    D: Deserializer<'de>,
134{
135    #[derive(Deserialize)]
136    struct Helper(#[serde(deserialize_with = "deserialize_u64")] u64);
137
138    let helper = Option::<Helper>::deserialize(deserializer)?;
139    Ok(helper.map(|Helper(value)| value))
140}
141
142#[cfg(test)]
143mod tests {
144    use super::*;
145    use serde::de::value::{
146        Error as ValueError, I64Deserializer, StringDeserializer, U64Deserializer,
147    };
148    use serde_json;
149
150    #[test]
151    fn test_deserialize_u128_from_string() {
152        let input = "12345";
153        let deserializer = StringDeserializer::<ValueError>::new(input.to_string());
154        let result = deserialize_u128(deserializer);
155        assert!(result.is_ok());
156        assert_eq!(result.unwrap(), 12345);
157    }
158
159    #[test]
160    fn test_deserialize_u128_from_string_large_value() {
161        let input = "340282366920938463463374607431768211455"; // u128::MAX
162        let deserializer = StringDeserializer::<ValueError>::new(input.to_string());
163        let result = deserialize_u128(deserializer);
164        assert!(result.is_ok());
165        assert_eq!(result.unwrap(), u128::MAX);
166    }
167
168    #[test]
169    fn test_deserialize_u128_from_invalid_string() {
170        let input = "not a number";
171        let deserializer = StringDeserializer::<ValueError>::new(input.to_string());
172        let result = deserialize_u128(deserializer);
173        assert!(result.is_err());
174    }
175
176    #[test]
177    fn test_deserialize_u128_from_u64() {
178        let input: u64 = 54321;
179        let deserializer = U64Deserializer::<ValueError>::new(input);
180        let result = deserialize_u128(deserializer);
181        assert!(result.is_ok());
182        assert_eq!(result.unwrap(), 54321u128);
183    }
184
185    #[test]
186    fn test_deserialize_u128_from_i64_positive() {
187        let input: i64 = 9876;
188        let deserializer = I64Deserializer::<ValueError>::new(input);
189        let result = deserialize_u128(deserializer);
190        assert!(result.is_ok());
191        assert_eq!(result.unwrap(), 9876u128);
192    }
193
194    #[test]
195    fn test_deserialize_u128_from_i64_negative() {
196        let input: i64 = -123;
197        let deserializer = I64Deserializer::<ValueError>::new(input);
198        let result = deserialize_u128(deserializer);
199        assert!(result.is_err());
200    }
201
202    #[derive(Deserialize)]
203    struct TestStructOptionalU128 {
204        #[serde(deserialize_with = "deserialize_optional_u128")]
205        value: Option<u128>,
206    }
207
208    #[test]
209    fn test_deserialize_optional_u128() {
210        let json = r#"{"value": "12345"}"#;
211        let result: TestStructOptionalU128 = serde_json::from_str(json).unwrap();
212        assert_eq!(result.value, Some(12345u128));
213    }
214
215    #[test]
216    fn test_deserialize_optional_u128_none() {
217        let json = r#"{"value": null}"#;
218        let result: TestStructOptionalU128 = serde_json::from_str(json).unwrap();
219        assert_eq!(result.value, None);
220    }
221
222    #[derive(Deserialize)]
223    struct TestStructOptionalU64 {
224        #[serde(deserialize_with = "deserialize_optional_u64")]
225        value: Option<u64>,
226    }
227
228    #[test]
229    fn test_deserialize_optional_u64() {
230        let json = r#"{"value": "12345"}"#;
231        let result: TestStructOptionalU64 = serde_json::from_str(json).unwrap();
232        assert_eq!(result.value, Some(12345u64));
233    }
234
235    #[test]
236    fn test_deserialize_optional_u64_none() {
237        let json = r#"{"value": null}"#;
238        let result: TestStructOptionalU64 = serde_json::from_str(json).unwrap();
239        assert_eq!(result.value, None);
240    }
241
242    // Test serialization functions
243    #[test]
244    fn test_serialize_u128() {
245        let value: u128 = 340282366920938463463374607431768211455; // u128::MAX
246        let serialized = serde_json::to_string_pretty(&serde_json::json!({
247            "test": serde_json::to_value(value.to_string()).unwrap()
248        }))
249        .unwrap();
250
251        assert!(serialized.contains("340282366920938463463374607431768211455"));
252    }
253
254    // Test round-trip serialization/deserialization
255    use serde::{Deserialize, Serialize};
256
257    #[derive(Serialize, Deserialize, PartialEq, Debug)]
258    struct TestSerializeStruct {
259        #[serde(
260            serialize_with = "serialize_optional_u128",
261            deserialize_with = "deserialize_optional_u128"
262        )]
263        value: Option<u128>,
264    }
265
266    #[test]
267    fn test_serialize_deserialize_roundtrip_large_value() {
268        let original = TestSerializeStruct {
269            value: Some(u128::MAX),
270        };
271
272        let json = serde_json::to_string(&original).unwrap();
273        let deserialized: TestSerializeStruct = serde_json::from_str(&json).unwrap();
274
275        assert_eq!(original, deserialized);
276        assert!(json.contains("340282366920938463463374607431768211455"));
277    }
278
279    #[test]
280    fn test_serialize_deserialize_roundtrip_none() {
281        let original = TestSerializeStruct { value: None };
282
283        let json = serde_json::to_string(&original).unwrap();
284        let deserialized: TestSerializeStruct = serde_json::from_str(&json).unwrap();
285
286        assert_eq!(original, deserialized);
287        assert!(json.contains("null"));
288    }
289
290    #[test]
291    fn test_serialize_deserialize_roundtrip_small_value() {
292        let original = TestSerializeStruct { value: Some(12345) };
293
294        let json = serde_json::to_string(&original).unwrap();
295        let deserialized: TestSerializeStruct = serde_json::from_str(&json).unwrap();
296
297        assert_eq!(original, deserialized);
298        assert!(json.contains("12345"));
299    }
300}
openzeppelin_relayer/utils/serde/u128_deserializer.rs

openzeppelin_relayer/utils/serde/
u128_deserializer.rs
