nado_sdk/nado_utils/
serialize_utils.rs

1use ethers::types::{H160, H256, I256, U256};
2use ethers_core::types::{Bytes, H512};
3use eyre::Result;
4use serde::de::{Error, SeqAccess, Visitor};
5use serde::ser::SerializeSeq;
6use serde::{Deserialize, Deserializer, Serialize, Serializer};
7use std::fmt;
8use std::str::{from_utf8, FromStr};
9
10const MAP: &[u8] = "0123456789abcdef".as_bytes();
11
12pub fn str_or_u32<'de, D>(deserializer: D) -> Result<u32, D::Error>
13where
14    D: Deserializer<'de>,
15{
16    #[derive(Deserialize)]
17    #[serde(untagged)]
18    enum StrOrU32<'a> {
19        Str(&'a str),
20        U32(u32),
21    }
22
23    Ok(match StrOrU32::deserialize(deserializer)? {
24        StrOrU32::Str(v) => v.parse().unwrap_or(0), // Ignoring parsing errors
25        StrOrU32::U32(v) => v,
26    })
27}
28
29pub fn u32_within_i32_range<'de, D>(deserializer: D) -> Result<u32, D::Error>
30where
31    D: Deserializer<'de>,
32{
33    let v = u32::deserialize(deserializer)?;
34    if u32_in_i32_range(v) {
35        Ok(v)
36    } else {
37        Err(D::Error::custom("u32 value too large"))
38    }
39}
40
41fn u32_in_i32_range(v: u32) -> bool {
42    v <= i32::MAX as u32
43}
44
45pub fn str_or_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
46where
47    D: Deserializer<'de>,
48{
49    #[derive(Deserialize)]
50    #[serde(untagged)]
51    enum StrOrU64<'a> {
52        Str(&'a str),
53        String(String),
54        U64(u64),
55    }
56
57    let v = match StrOrU64::deserialize(deserializer)? {
58        StrOrU64::Str(v) => v.parse().unwrap_or(0), // Ignoring parsing errors
59        StrOrU64::String(v) => v.parse().unwrap_or(0),
60        StrOrU64::U64(v) => v,
61    };
62    if u64_in_i64_range(v) {
63        Ok(v)
64    } else {
65        Err(D::Error::custom("u64 value too large"))
66    }
67}
68
69pub fn strict_str_or_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
70where
71    D: Deserializer<'de>,
72{
73    if !deserializer.is_human_readable() {
74        return u64::deserialize(deserializer);
75    }
76
77    #[derive(Deserialize)]
78    #[serde(untagged)]
79    enum StringOrU64 {
80        String(String),
81        U64(u64),
82    }
83
84    match StringOrU64::deserialize(deserializer)? {
85        StringOrU64::String(value) => value.parse().map_err(D::Error::custom),
86        StringOrU64::U64(value) => Ok(value),
87    }
88}
89
90pub fn opt_str_or_u64<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
91where
92    D: Deserializer<'de>,
93{
94    #[derive(Deserialize)]
95    #[serde(untagged)]
96    enum Either {
97        Str(String),
98        U64(u64),
99    }
100    Option::<Either>::deserialize(deserializer).map(|opt| {
101        opt.and_then(|v| match v {
102            Either::Str(s) => s.parse().ok(),
103            Either::U64(n) => Some(n),
104        })
105    })
106}
107
108fn u64_in_i64_range(v: u64) -> bool {
109    v <= i64::MAX as u64
110}
111
112pub fn str_or_f64<'de, D>(deserializer: D) -> Result<f64, D::Error>
113where
114    D: Deserializer<'de>,
115{
116    #[derive(Deserialize)]
117    #[serde(untagged)]
118    enum StrOrF64<'a> {
119        Str(&'a str),
120        String(String),
121        F64(f64),
122    }
123
124    Ok(match StrOrF64::deserialize(deserializer)? {
125        StrOrF64::Str(v) => v.parse().map_err(D::Error::custom)?,
126        StrOrF64::String(v) => v.parse().map_err(D::Error::custom)?,
127        StrOrF64::F64(v) => v,
128    })
129}
130
131// why do we have this when there is str_or_u64 above?
132// what's above allows us to take query inputs as u64s or strings; it works great for json
133// because json is self-describing, but it won't work with bincode because bincode is not
134// so on structs that are serialized in both json and bincode, we need to use this
135// and just serialize all u64s as strings
136pub fn serialize_u64<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
137where
138    S: Serializer,
139{
140    serializer.serialize_str(&value.to_string())
141}
142
143pub fn deserialize_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
144where
145    D: Deserializer<'de>,
146{
147    let s = String::deserialize(deserializer)?;
148    u64::from_str(&s).map_err(|_| D::Error::custom("invalid u64 value"))
149}
150
151pub fn serialize_option_u64<S>(value: &Option<u64>, serializer: S) -> Result<S::Ok, S::Error>
152where
153    S: Serializer,
154{
155    if let Some(value) = value {
156        serializer.serialize_some(&value.to_string())
157    } else {
158        serializer.serialize_none()
159    }
160}
161
162pub fn deserialize_option_u64<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
163where
164    D: Deserializer<'de>,
165{
166    let opt = Option::<String>::deserialize(deserializer)?;
167    opt.map(|s| u64::from_str(&s).map_err(|_| D::Error::custom("invalid u64 value")))
168        .transpose()
169}
170
171pub fn serialize_u128<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
172where
173    S: Serializer,
174{
175    serializer.serialize_str(&value.to_string())
176}
177
178pub fn deserialize_u128<'de, D>(deserializer: D) -> Result<u128, D::Error>
179where
180    D: Deserializer<'de>,
181{
182    let s = String::deserialize(deserializer)?;
183    s.parse()
184        .map_err(|_| D::Error::custom("invalid u128 value"))
185}
186
187pub fn serialize_i128<S>(value: &i128, serializer: S) -> Result<S::Ok, S::Error>
188where
189    S: Serializer,
190{
191    serializer.serialize_str(&value.to_string())
192}
193
194pub fn deserialize_i128<'de, D>(deserializer: D) -> Result<i128, D::Error>
195where
196    D: Deserializer<'de>,
197{
198    let s = String::deserialize(deserializer)?;
199    s.parse()
200        .map_err(|_| D::Error::custom("invalid i128 value"))
201}
202
203pub fn serialize_option_i128<S>(value: &Option<i128>, serializer: S) -> Result<S::Ok, S::Error>
204where
205    S: Serializer,
206{
207    if let Some(value) = value {
208        serializer.serialize_some(&value.to_string())
209    } else {
210        serializer.serialize_none()
211    }
212}
213
214pub fn deserialize_option_i128<'de, D>(deserializer: D) -> Result<Option<i128>, D::Error>
215where
216    D: Deserializer<'de>,
217{
218    Option::<WrappedI128>::deserialize(deserializer)
219        .map(|opt_wrapped: Option<WrappedI128>| opt_wrapped.map(|wrapped: WrappedI128| wrapped.0))
220}
221
222pub fn serialize_i64<S>(value: &i64, serializer: S) -> Result<S::Ok, S::Error>
223where
224    S: Serializer,
225{
226    serializer.serialize_str(&value.to_string())
227}
228
229pub fn deserialize_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
230where
231    D: Deserializer<'de>,
232{
233    let s = String::deserialize(deserializer)?;
234    s.parse().map_err(|_| D::Error::custom("invalid i64 value"))
235}
236
237pub fn serialize_option_i64<S>(value: &Option<i64>, serializer: S) -> Result<S::Ok, S::Error>
238where
239    S: Serializer,
240{
241    if let Some(value) = value {
242        serializer.serialize_some(&value.to_string())
243    } else {
244        serializer.serialize_none()
245    }
246}
247
248pub fn deserialize_option_i64<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
249where
250    D: Deserializer<'de>,
251{
252    let opt = Option::<String>::deserialize(deserializer)?;
253    opt.map(|s| s.parse().map_err(|_| D::Error::custom("invalid i64 value")))
254        .transpose()
255}
256
257#[derive(
258    rkyv::Archive,
259    rkyv::Deserialize,
260    rkyv::Serialize,
261    Clone,
262    Debug,
263    Eq,
264    PartialEq,
265    Serialize,
266    Deserialize,
267    Default,
268)]
269#[archive(check_bytes)]
270pub struct WrappedI128(
271    #[serde(
272        serialize_with = "serialize_i128",
273        deserialize_with = "deserialize_i128"
274    )]
275    pub i128,
276);
277
278pub fn serialize_vec_i128<S>(value: &Vec<i128>, serializer: S) -> Result<S::Ok, S::Error>
279where
280    S: Serializer,
281{
282    let mut seq = serializer.serialize_seq(Some(value.len()))?;
283    for e in value {
284        seq.serialize_element(&WrappedI128(*e))?;
285    }
286    seq.end()
287}
288
289struct VecI128Deserializer;
290
291impl<'de> Visitor<'de> for VecI128Deserializer {
292    type Value = Vec<i128>;
293
294    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
295        formatter.write_str("vector sequence.")
296    }
297
298    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
299    where
300        A: SeqAccess<'de>,
301    {
302        let mut ret = Vec::<i128>::new();
303        while let Some(v) = seq.next_element::<WrappedI128>()? {
304            ret.push(v.0);
305        }
306        Ok(ret)
307    }
308}
309
310pub fn deserialize_vec_i128<'de, D>(deserializer: D) -> Result<Vec<i128>, D::Error>
311where
312    D: Deserializer<'de>,
313{
314    deserializer.deserialize_seq(VecI128Deserializer)
315}
316
317#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
318pub struct WrappedVecI128(
319    #[serde(
320        serialize_with = "serialize_vec_i128",
321        deserialize_with = "deserialize_vec_i128"
322    )]
323    pub Vec<i128>,
324);
325
326pub fn serialize_nested_vec_i128<S>(
327    value: &Vec<Vec<i128>>,
328    serializer: S,
329) -> Result<S::Ok, S::Error>
330where
331    S: Serializer,
332{
333    let mut seq = serializer.serialize_seq(Some(value.len()))?;
334    for e in value {
335        seq.serialize_element(&WrappedVecI128(e.clone()))?;
336    }
337    seq.end()
338}
339
340struct NestedVecI128Deserializer;
341
342impl<'de> Visitor<'de> for NestedVecI128Deserializer {
343    type Value = Vec<Vec<i128>>;
344
345    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
346        formatter.write_str("nested vector sequence.")
347    }
348
349    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
350    where
351        A: SeqAccess<'de>,
352    {
353        let mut ret = Vec::<Vec<i128>>::new();
354        while let Some(v) = seq.next_element::<WrappedVecI128>()? {
355            ret.push(v.0);
356        }
357        Ok(ret)
358    }
359}
360
361pub fn deserialize_nested_vec_i128<'de, D>(deserializer: D) -> Result<Vec<Vec<i128>>, D::Error>
362where
363    D: Deserializer<'de>,
364{
365    deserializer.deserialize_seq(NestedVecI128Deserializer)
366}
367
368pub fn serialize_u256<S>(value: &U256, serializer: S) -> Result<S::Ok, S::Error>
369where
370    S: Serializer,
371{
372    serializer.serialize_str(&value.to_string())
373}
374
375pub fn deserialize_u256<'de, D>(deserializer: D) -> Result<U256, D::Error>
376where
377    D: Deserializer<'de>,
378{
379    let s = String::deserialize(deserializer)?;
380    U256::from_dec_str(&s).map_err(|_| D::Error::custom("invalid u256 value"))
381}
382
383pub fn serialize_i256<S>(value: &I256, serializer: S) -> Result<S::Ok, S::Error>
384where
385    S: Serializer,
386{
387    serializer.serialize_str(&value.to_string())
388}
389
390pub fn deserialize_i256<'de, D>(deserializer: D) -> Result<I256, D::Error>
391where
392    D: Deserializer<'de>,
393{
394    let s = String::deserialize(deserializer)?;
395    I256::from_dec_str(&s).map_err(|_| D::Error::custom("invalid i256 value"))
396}
397
398pub fn serialize_bytes64<S>(value: &[u8; 64], serializer: S) -> Result<S::Ok, S::Error>
399where
400    S: Serializer,
401{
402    let mut hex = [0u8; 130];
403    hex[0] = b'0';
404    hex[1] = b'x';
405    for i in 0..64 {
406        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
407        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
408    }
409    serializer.serialize_str(from_utf8(&hex).unwrap())
410}
411
412pub fn deserialize_bytes64<'de, D>(deserializer: D) -> Result<[u8; 64], D::Error>
413where
414    D: Deserializer<'de>,
415{
416    let s = String::deserialize(deserializer)?;
417    Ok(H512::from_str(&s)
418        .map_err(|_| D::Error::custom("invalid H256 value"))?
419        .to_fixed_bytes())
420}
421
422pub fn serialize_bytes32<S>(value: &[u8; 32], serializer: S) -> Result<S::Ok, S::Error>
423where
424    S: Serializer,
425{
426    let mut hex = [0u8; 66];
427    hex[0] = b'0';
428    hex[1] = b'x';
429    for i in 0..32 {
430        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
431        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
432    }
433    serializer.serialize_str(from_utf8(&hex).unwrap())
434}
435
436pub fn deserialize_bytes32<'de, D>(deserializer: D) -> Result<[u8; 32], D::Error>
437where
438    D: Deserializer<'de>,
439{
440    let s = String::deserialize(deserializer)?;
441    Ok(H256::from_str(&s)
442        .map_err(|_| D::Error::custom("invalid H256 value"))?
443        .to_fixed_bytes())
444}
445
446pub fn serialize_bytes20<S>(value: &[u8; 20], serializer: S) -> Result<S::Ok, S::Error>
447where
448    S: Serializer,
449{
450    let mut hex = [0u8; 42];
451    hex[0] = b'0';
452    hex[1] = b'x';
453    for i in 0..20 {
454        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
455        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
456    }
457    serializer.serialize_str(from_utf8(&hex).unwrap())
458}
459
460pub fn deserialize_bytes20<'de, D>(deserializer: D) -> Result<[u8; 20], D::Error>
461where
462    D: Deserializer<'de>,
463{
464    let s = String::deserialize(deserializer)?;
465    Ok(H160::from_str(&s)
466        .map_err(|_| D::Error::custom("invalid H160 value"))?
467        .to_fixed_bytes())
468}
469
470#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
471pub struct WrappedVecU8(
472    #[serde(
473        serialize_with = "serialize_vec_u8",
474        deserialize_with = "deserialize_vec_u8"
475    )]
476    pub Vec<u8>,
477);
478
479pub fn serialize_option_vec_u8<S>(value: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
480where
481    S: Serializer,
482{
483    if let Some(value) = value {
484        serializer.serialize_some(&WrappedVecU8(value.clone()))
485    } else {
486        serializer.serialize_none()
487    }
488}
489
490pub fn deserialize_option_vec_u8<'de, D>(deserializer: D) -> Result<Option<Vec<u8>>, D::Error>
491where
492    D: Deserializer<'de>,
493{
494    Option::<WrappedVecU8>::deserialize(deserializer)
495        .map(|opt_wrapped: Option<WrappedVecU8>| opt_wrapped.map(|wrapped: WrappedVecU8| wrapped.0))
496}
497
498pub fn serialize_vec_u8<S>(value: &[u8], serializer: S) -> Result<S::Ok, S::Error>
499where
500    S: Serializer,
501{
502    let mut hex = vec![0; value.len() * 2 + 2];
503    hex[0] = b'0';
504    hex[1] = b'x';
505    for i in 0..value.len() {
506        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
507        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
508    }
509    serializer.serialize_str(from_utf8(&hex).unwrap())
510}
511
512pub fn deserialize_vec_u8<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
513where
514    D: Deserializer<'de>,
515{
516    let s = String::deserialize(deserializer)?;
517
518    Ok(Bytes::from_str(&s)
519        .map_err(|_| D::Error::custom("invalid Bytes value"))?
520        .to_vec())
521}
522
523#[derive(Hash, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
524pub struct WrappedBytes32(
525    #[serde(
526        serialize_with = "serialize_bytes32",
527        deserialize_with = "deserialize_bytes32"
528    )]
529    pub [u8; 32],
530);
531
532#[derive(
533    Hash,
534    Clone,
535    Debug,
536    Eq,
537    PartialEq,
538    Serialize,
539    Deserialize,
540    rkyv::Archive,
541    rkyv::Deserialize,
542    rkyv::Serialize,
543)]
544pub struct WrappedBytes64(
545    #[serde(
546        serialize_with = "serialize_bytes64",
547        deserialize_with = "deserialize_bytes64"
548    )]
549    pub [u8; 64],
550);
551
552#[derive(Hash, Clone, Debug, Eq, PartialEq, Deserialize, Serialize, Default)]
553pub struct WrappedU64(
554    #[serde(deserialize_with = "str_or_u64", serialize_with = "serialize_u64")] pub u64,
555);
556
557#[derive(Hash, Clone, Debug, Eq, PartialEq, Deserialize, Serialize, Copy)]
558pub struct WrappedU32(#[serde(deserialize_with = "u32_within_i32_range")] pub u32);
559
560impl WrappedU32 {
561    pub fn convert_to_vec_i32(v: &[WrappedU32]) -> Vec<i32> {
562        v.iter().map(|x| i32::from(*x)).collect()
563    }
564
565    pub fn wrap_vec_u32(v: &[u32]) -> Vec<WrappedU32> {
566        v.iter().map(|x| WrappedU32(*x)).collect()
567    }
568}
569
570impl From<WrappedU32> for i32 {
571    fn from(wrapped: WrappedU32) -> Self {
572        wrapped.0 as i32
573    }
574}
575
576pub fn deserialize_option_bytes32<'de, D>(deserializer: D) -> Result<Option<[u8; 32]>, D::Error>
577where
578    D: Deserializer<'de>,
579{
580    Option::<WrappedBytes32>::deserialize(deserializer).map(
581        |opt_wrapped: Option<WrappedBytes32>| opt_wrapped.map(|wrapped: WrappedBytes32| wrapped.0),
582    )
583}
584
585pub fn serialize_option_bytes32<S>(
586    value: &Option<[u8; 32]>,
587    serializer: S,
588) -> Result<S::Ok, S::Error>
589where
590    S: Serializer,
591{
592    if let Some(value) = value {
593        serializer.serialize_some(&WrappedBytes32(*value))
594    } else {
595        serializer.serialize_none()
596    }
597}
598
599pub fn deserialize_option_bytes64<'de, D>(deserializer: D) -> Result<Option<[u8; 64]>, D::Error>
600where
601    D: Deserializer<'de>,
602{
603    Option::<WrappedBytes64>::deserialize(deserializer).map(
604        |opt_wrapped: Option<WrappedBytes64>| opt_wrapped.map(|wrapped: WrappedBytes64| wrapped.0),
605    )
606}
607
608pub fn serialize_option_bytes64<S>(
609    value: &Option<[u8; 64]>,
610    serializer: S,
611) -> Result<S::Ok, S::Error>
612where
613    S: Serializer,
614{
615    if let Some(value) = value {
616        serializer.serialize_some(&WrappedBytes64(*value))
617    } else {
618        serializer.serialize_none()
619    }
620}
621
622struct VecBytes32Deserializer;
623
624impl<'de> Visitor<'de> for VecBytes32Deserializer {
625    type Value = Vec<[u8; 32]>;
626
627    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
628        formatter.write_str("vector sequence.")
629    }
630
631    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
632    where
633        A: SeqAccess<'de>,
634    {
635        let mut ret = Vec::<[u8; 32]>::new();
636        while let Some(v) = seq.next_element::<H256>()? {
637            ret.push(v.to_fixed_bytes());
638        }
639        Ok(ret)
640    }
641}
642
643pub fn serialize_vec_bytes32<S>(value: &Vec<[u8; 32]>, serializer: S) -> Result<S::Ok, S::Error>
644where
645    S: Serializer,
646{
647    let mut seq = serializer.serialize_seq(Some(value.len()))?;
648    for e in value {
649        seq.serialize_element(&WrappedBytes32(*e))?;
650    }
651    seq.end()
652}
653
654pub fn deserialize_vec_bytes32<'de, D>(deserializer: D) -> Result<Vec<[u8; 32]>, D::Error>
655where
656    D: Deserializer<'de>,
657{
658    deserializer.deserialize_seq(VecBytes32Deserializer)
659}
660
661#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
662pub struct WrappedBytes20(
663    #[serde(
664        serialize_with = "serialize_bytes20",
665        deserialize_with = "deserialize_bytes20"
666    )]
667    pub [u8; 20],
668);
669
670pub fn serialize_option_bytes20<S>(
671    value: &Option<[u8; 20]>,
672    serializer: S,
673) -> Result<S::Ok, S::Error>
674where
675    S: Serializer,
676{
677    if let Some(value) = value {
678        serializer.serialize_some(&WrappedBytes20(*value))
679    } else {
680        serializer.serialize_none()
681    }
682}
683
684pub fn deserialize_option_bytes20<'de, D>(deserializer: D) -> Result<Option<[u8; 20]>, D::Error>
685where
686    D: Deserializer<'de>,
687{
688    Option::<WrappedBytes20>::deserialize(deserializer).map(
689        |opt_wrapped: Option<WrappedBytes20>| opt_wrapped.map(|wrapped: WrappedBytes20| wrapped.0),
690    )
691}
692
693struct VecBytes20Deserializer;
694
695impl<'de> Visitor<'de> for VecBytes20Deserializer {
696    type Value = Vec<[u8; 20]>;
697
698    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
699        formatter.write_str("vector sequence.")
700    }
701
702    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
703    where
704        A: SeqAccess<'de>,
705    {
706        let mut ret = Vec::<[u8; 20]>::new();
707        while let Some(v) = seq.next_element::<H160>()? {
708            ret.push(v.to_fixed_bytes());
709        }
710        Ok(ret)
711    }
712}
713
714pub fn serialize_vec_bytes20<S>(value: &Vec<[u8; 20]>, serializer: S) -> Result<S::Ok, S::Error>
715where
716    S: Serializer,
717{
718    let mut seq = serializer.serialize_seq(Some(value.len()))?;
719    for e in value {
720        seq.serialize_element(&WrappedBytes20(*e))?;
721    }
722    seq.end()
723}
724
725pub fn deserialize_vec_bytes20<'de, D>(deserializer: D) -> Result<Vec<[u8; 20]>, D::Error>
726where
727    D: Deserializer<'de>,
728{
729    deserializer.deserialize_seq(VecBytes20Deserializer)
730}
731
732#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
733pub struct WrappedVecBytes20(
734    #[serde(
735        serialize_with = "serialize_vec_bytes20",
736        deserialize_with = "deserialize_vec_bytes20"
737    )]
738    pub Vec<[u8; 20]>,
739);
740
741pub fn serialize_option_vec_bytes20<S>(
742    value: &Option<Vec<[u8; 20]>>,
743    serializer: S,
744) -> Result<S::Ok, S::Error>
745where
746    S: Serializer,
747{
748    if let Some(value) = value {
749        serializer.serialize_some(&WrappedVecBytes20(value.clone()))
750    } else {
751        serializer.serialize_none()
752    }
753}
754
755pub fn deserialize_option_vec_bytes20<'de, D>(
756    deserializer: D,
757) -> Result<Option<Vec<[u8; 20]>>, D::Error>
758where
759    D: Deserializer<'de>,
760{
761    Option::<WrappedVecBytes20>::deserialize(deserializer).map(
762        |opt_wrapped: Option<WrappedVecBytes20>| {
763            opt_wrapped.map(|wrapped: WrappedVecBytes20| wrapped.0)
764        },
765    )
766}
767
768pub fn serialize_f64<S>(value: &f64, serializer: S) -> Result<S::Ok, S::Error>
769where
770    S: Serializer,
771{
772    serializer.serialize_str(&value.to_string())
773}
774
775pub fn deserialize_f64<'de, D>(deserializer: D) -> Result<f64, D::Error>
776where
777    D: Deserializer<'de>,
778{
779    let s = String::deserialize(deserializer)?;
780    f64::from_str(&s).map_err(|_| D::Error::custom("invalid f64 value"))
781}
782
783#[derive(Clone, Debug, PartialEq, Deserialize, Serialize, Default)]
784pub struct WrappedF64(
785    #[serde(deserialize_with = "deserialize_f64", serialize_with = "serialize_f64")] pub f64,
786);
787
788pub fn serialize_option_f64<S>(value: &Option<f64>, serializer: S) -> Result<S::Ok, S::Error>
789where
790    S: Serializer,
791{
792    if let Some(value) = value {
793        serializer.serialize_some(&value.to_string())
794    } else {
795        serializer.serialize_none()
796    }
797}
798
799pub fn deserialize_option_f64<'de, D>(deserializer: D) -> Result<Option<f64>, D::Error>
800where
801    D: Deserializer<'de>,
802{
803    Option::<WrappedF64>::deserialize(deserializer)
804        .map(|opt_wrapped: Option<WrappedF64>| opt_wrapped.map(|wrapped: WrappedF64| wrapped.0))
805}
806
807pub fn str_or_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
808where
809    D: Deserializer<'de>,
810{
811    #[derive(Deserialize)]
812    #[serde(untagged)]
813    enum StrOrU64<'a> {
814        Str(&'a str),
815        I64(i64),
816    }
817    Ok(match StrOrU64::deserialize(deserializer)? {
818        StrOrU64::Str(v) => v.parse().unwrap_or(0), // Ignoring parsing errors
819        StrOrU64::I64(v) => v,
820    })
821}
822
823pub fn serialize_u64_keyed_map<S, V>(
824    map: &std::collections::HashMap<u64, V>,
825    serializer: S,
826) -> Result<S::Ok, S::Error>
827where
828    S: Serializer,
829    V: Serialize,
830{
831    use serde::ser::SerializeMap;
832    let mut m = serializer.serialize_map(Some(map.len()))?;
833    for (k, v) in map {
834        m.serialize_entry(&k.to_string(), v)?;
835    }
836    m.end()
837}
838
839pub fn deserialize_u64_keyed_map<'de, D, V>(
840    deserializer: D,
841) -> Result<std::collections::HashMap<u64, V>, D::Error>
842where
843    D: Deserializer<'de>,
844    V: Deserialize<'de>,
845{
846    std::collections::HashMap::<String, V>::deserialize(deserializer)?
847        .into_iter()
848        .map(|(k, v)| k.parse::<u64>().map(|k| (k, v)).map_err(Error::custom))
849        .collect()
850}
nado_sdk/nado_utils/serialize_utils.rs

nado_sdk/nado_utils/
serialize_utils.rs
