vertex_sdk/vertex_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
69fn u64_in_i64_range(v: u64) -> bool {
70    v <= i64::MAX as u64
71}
72
73// why do we have this when there is str_or_u64 above?
74// what's above allows us to take query inputs as u64s or strings; it works great for json
75// because json is self-describing, but it won't work with bincode because bincode is not
76// so on structs that are serialized in both json and bincode, we need to use this
77// and just serialize all u64s as strings
78pub fn serialize_u64<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
79where
80    S: Serializer,
81{
82    serializer.serialize_str(&value.to_string())
83}
84
85pub fn deserialize_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
86where
87    D: Deserializer<'de>,
88{
89    let s = String::deserialize(deserializer)?;
90    u64::from_str(&s).map_err(|_| D::Error::custom("invalid u64 value"))
91}
92
93pub fn serialize_u128<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
94where
95    S: Serializer,
96{
97    serializer.serialize_str(&value.to_string())
98}
99
100pub fn deserialize_u128<'de, D>(deserializer: D) -> Result<u128, D::Error>
101where
102    D: Deserializer<'de>,
103{
104    let s = String::deserialize(deserializer)?;
105    s.parse()
106        .map_err(|_| D::Error::custom("invalid u128 value"))
107}
108
109pub fn serialize_i128<S>(value: &i128, serializer: S) -> Result<S::Ok, S::Error>
110where
111    S: Serializer,
112{
113    serializer.serialize_str(&value.to_string())
114}
115
116pub fn deserialize_i128<'de, D>(deserializer: D) -> Result<i128, D::Error>
117where
118    D: Deserializer<'de>,
119{
120    let s = String::deserialize(deserializer)?;
121    s.parse()
122        .map_err(|_| D::Error::custom("invalid i128 value"))
123}
124
125pub fn serialize_i64<S>(value: &i64, serializer: S) -> Result<S::Ok, S::Error>
126where
127    S: Serializer,
128{
129    serializer.serialize_str(&value.to_string())
130}
131
132pub fn deserialize_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
133where
134    D: Deserializer<'de>,
135{
136    let s = String::deserialize(deserializer)?;
137    s.parse().map_err(|_| D::Error::custom("invalid i64 value"))
138}
139
140#[derive(
141    rkyv::Archive,
142    rkyv::Deserialize,
143    rkyv::Serialize,
144    Clone,
145    Debug,
146    Eq,
147    PartialEq,
148    Serialize,
149    Deserialize,
150    Default,
151)]
152#[archive(check_bytes)]
153pub struct WrappedI128(
154    #[serde(
155        serialize_with = "serialize_i128",
156        deserialize_with = "deserialize_i128"
157    )]
158    pub i128,
159);
160
161pub fn serialize_vec_i128<S>(value: &Vec<i128>, serializer: S) -> Result<S::Ok, S::Error>
162where
163    S: Serializer,
164{
165    let mut seq = serializer.serialize_seq(Some(value.len()))?;
166    for e in value {
167        seq.serialize_element(&WrappedI128(*e))?;
168    }
169    seq.end()
170}
171
172struct VecI128Deserializer;
173
174impl<'de> Visitor<'de> for VecI128Deserializer {
175    type Value = Vec<i128>;
176
177    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
178        formatter.write_str("vector sequence.")
179    }
180
181    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
182    where
183        A: SeqAccess<'de>,
184    {
185        let mut ret = Vec::<i128>::new();
186        while let Some(v) = seq.next_element::<WrappedI128>()? {
187            ret.push(v.0);
188        }
189        Ok(ret)
190    }
191}
192
193pub fn deserialize_vec_i128<'de, D>(deserializer: D) -> Result<Vec<i128>, D::Error>
194where
195    D: Deserializer<'de>,
196{
197    deserializer.deserialize_seq(VecI128Deserializer)
198}
199
200#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
201pub struct WrappedVecI128(
202    #[serde(
203        serialize_with = "serialize_vec_i128",
204        deserialize_with = "deserialize_vec_i128"
205    )]
206    pub Vec<i128>,
207);
208
209pub fn serialize_nested_vec_i128<S>(
210    value: &Vec<Vec<i128>>,
211    serializer: S,
212) -> Result<S::Ok, S::Error>
213where
214    S: Serializer,
215{
216    let mut seq = serializer.serialize_seq(Some(value.len()))?;
217    for e in value {
218        seq.serialize_element(&WrappedVecI128(e.clone()))?;
219    }
220    seq.end()
221}
222
223struct NestedVecI128Deserializer;
224
225impl<'de> Visitor<'de> for NestedVecI128Deserializer {
226    type Value = Vec<Vec<i128>>;
227
228    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
229        formatter.write_str("nested vector sequence.")
230    }
231
232    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
233    where
234        A: SeqAccess<'de>,
235    {
236        let mut ret = Vec::<Vec<i128>>::new();
237        while let Some(v) = seq.next_element::<WrappedVecI128>()? {
238            ret.push(v.0);
239        }
240        Ok(ret)
241    }
242}
243
244pub fn deserialize_nested_vec_i128<'de, D>(deserializer: D) -> Result<Vec<Vec<i128>>, D::Error>
245where
246    D: Deserializer<'de>,
247{
248    deserializer.deserialize_seq(NestedVecI128Deserializer)
249}
250
251pub fn serialize_u256<S>(value: &U256, serializer: S) -> Result<S::Ok, S::Error>
252where
253    S: Serializer,
254{
255    serializer.serialize_str(&value.to_string())
256}
257
258pub fn deserialize_u256<'de, D>(deserializer: D) -> Result<U256, D::Error>
259where
260    D: Deserializer<'de>,
261{
262    let s = String::deserialize(deserializer)?;
263    U256::from_dec_str(&s).map_err(|_| D::Error::custom("invalid u256 value"))
264}
265
266pub fn serialize_i256<S>(value: &I256, serializer: S) -> Result<S::Ok, S::Error>
267where
268    S: Serializer,
269{
270    serializer.serialize_str(&value.to_string())
271}
272
273pub fn deserialize_i256<'de, D>(deserializer: D) -> Result<I256, D::Error>
274where
275    D: Deserializer<'de>,
276{
277    let s = String::deserialize(deserializer)?;
278    I256::from_dec_str(&s).map_err(|_| D::Error::custom("invalid i256 value"))
279}
280
281pub fn serialize_bytes64<S>(value: &[u8; 64], serializer: S) -> Result<S::Ok, S::Error>
282where
283    S: Serializer,
284{
285    let mut hex = [0u8; 130];
286    hex[0] = b'0';
287    hex[1] = b'x';
288    for i in 0..64 {
289        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
290        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
291    }
292    serializer.serialize_str(from_utf8(&hex).unwrap())
293}
294
295pub fn deserialize_bytes64<'de, D>(deserializer: D) -> Result<[u8; 64], D::Error>
296where
297    D: Deserializer<'de>,
298{
299    let s = String::deserialize(deserializer)?;
300    Ok(H512::from_str(&s)
301        .map_err(|_| D::Error::custom("invalid H256 value"))?
302        .to_fixed_bytes())
303}
304
305pub fn serialize_bytes32<S>(value: &[u8; 32], serializer: S) -> Result<S::Ok, S::Error>
306where
307    S: Serializer,
308{
309    let mut hex = [0u8; 66];
310    hex[0] = b'0';
311    hex[1] = b'x';
312    for i in 0..32 {
313        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
314        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
315    }
316    serializer.serialize_str(from_utf8(&hex).unwrap())
317}
318
319pub fn deserialize_bytes32<'de, D>(deserializer: D) -> Result<[u8; 32], D::Error>
320where
321    D: Deserializer<'de>,
322{
323    let s = String::deserialize(deserializer)?;
324    Ok(H256::from_str(&s)
325        .map_err(|_| D::Error::custom("invalid H256 value"))?
326        .to_fixed_bytes())
327}
328
329pub fn serialize_bytes20<S>(value: &[u8; 20], serializer: S) -> Result<S::Ok, S::Error>
330where
331    S: Serializer,
332{
333    let mut hex = [0u8; 42];
334    hex[0] = b'0';
335    hex[1] = b'x';
336    for i in 0..20 {
337        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
338        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
339    }
340    serializer.serialize_str(from_utf8(&hex).unwrap())
341}
342
343pub fn deserialize_bytes20<'de, D>(deserializer: D) -> Result<[u8; 20], D::Error>
344where
345    D: Deserializer<'de>,
346{
347    let s = String::deserialize(deserializer)?;
348    Ok(H160::from_str(&s)
349        .map_err(|_| D::Error::custom("invalid H160 value"))?
350        .to_fixed_bytes())
351}
352
353#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
354pub struct WrappedVecU8(
355    #[serde(
356        serialize_with = "serialize_vec_u8",
357        deserialize_with = "deserialize_vec_u8"
358    )]
359    pub Vec<u8>,
360);
361
362pub fn serialize_option_vec_u8<S>(value: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
363where
364    S: Serializer,
365{
366    if let Some(value) = value {
367        serialize_vec_u8(value, serializer)
368    } else {
369        serializer.serialize_none()
370    }
371}
372
373pub fn deserialize_option_vec_u8<'de, D>(deserializer: D) -> Result<Option<Vec<u8>>, D::Error>
374where
375    D: Deserializer<'de>,
376{
377    Option::<WrappedVecU8>::deserialize(deserializer)
378        .map(|opt_wrapped: Option<WrappedVecU8>| opt_wrapped.map(|wrapped: WrappedVecU8| wrapped.0))
379}
380
381pub fn serialize_vec_u8<S>(value: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
382where
383    S: Serializer,
384{
385    let mut hex = vec![0; value.len() * 2 + 2];
386    hex[0] = b'0';
387    hex[1] = b'x';
388    for i in 0..value.len() {
389        hex[i * 2 + 2] = MAP[(value[i] >> 4) as usize];
390        hex[i * 2 + 1 + 2] = MAP[(value[i] & 0xf) as usize];
391    }
392    serializer.serialize_str(from_utf8(&hex).unwrap())
393}
394
395pub fn deserialize_vec_u8<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
396where
397    D: Deserializer<'de>,
398{
399    let s = String::deserialize(deserializer)?;
400
401    Ok(Bytes::from_str(&s)
402        .map_err(|_| D::Error::custom("invalid Bytes value"))?
403        .to_vec())
404}
405
406#[derive(Hash, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
407pub struct WrappedBytes32(
408    #[serde(
409        serialize_with = "serialize_bytes32",
410        deserialize_with = "deserialize_bytes32"
411    )]
412    pub [u8; 32],
413);
414
415#[derive(
416    Hash,
417    Clone,
418    Debug,
419    Eq,
420    PartialEq,
421    Serialize,
422    Deserialize,
423    rkyv::Archive,
424    rkyv::Deserialize,
425    rkyv::Serialize,
426)]
427pub struct WrappedBytes64(
428    #[serde(
429        serialize_with = "serialize_bytes64",
430        deserialize_with = "deserialize_bytes64"
431    )]
432    pub [u8; 64],
433);
434
435#[derive(Hash, Clone, Debug, Eq, PartialEq, Deserialize, Serialize, Default)]
436pub struct WrappedU64(
437    #[serde(deserialize_with = "str_or_u64", serialize_with = "serialize_u64")] pub u64,
438);
439
440#[derive(Hash, Clone, Debug, Eq, PartialEq, Deserialize, Serialize, Copy)]
441pub struct WrappedU32(#[serde(deserialize_with = "u32_within_i32_range")] pub u32);
442
443impl WrappedU32 {
444    pub fn convert_to_vec_i32(v: &[WrappedU32]) -> Vec<i32> {
445        v.iter().map(|x| i32::from(*x)).collect()
446    }
447
448    pub fn wrap_vec_u32(v: &[u32]) -> Vec<WrappedU32> {
449        v.iter().map(|x| WrappedU32(*x)).collect()
450    }
451}
452
453impl From<WrappedU32> for i32 {
454    fn from(wrapped: WrappedU32) -> Self {
455        wrapped.0 as i32
456    }
457}
458
459pub fn deserialize_option_bytes32<'de, D>(deserializer: D) -> Result<Option<[u8; 32]>, D::Error>
460where
461    D: Deserializer<'de>,
462{
463    Option::<WrappedBytes32>::deserialize(deserializer).map(
464        |opt_wrapped: Option<WrappedBytes32>| opt_wrapped.map(|wrapped: WrappedBytes32| wrapped.0),
465    )
466}
467
468pub fn serialize_option_bytes32<S>(
469    value: &Option<[u8; 32]>,
470    serializer: S,
471) -> Result<S::Ok, S::Error>
472where
473    S: Serializer,
474{
475    if let Some(value) = value {
476        serialize_bytes32(value, serializer)
477    } else {
478        serializer.serialize_none()
479    }
480}
481
482pub fn deserialize_option_bytes64<'de, D>(deserializer: D) -> Result<Option<[u8; 64]>, D::Error>
483where
484    D: Deserializer<'de>,
485{
486    Option::<WrappedBytes64>::deserialize(deserializer).map(
487        |opt_wrapped: Option<WrappedBytes64>| opt_wrapped.map(|wrapped: WrappedBytes64| wrapped.0),
488    )
489}
490
491pub fn serialize_option_bytes64<S>(
492    value: &Option<[u8; 64]>,
493    serializer: S,
494) -> Result<S::Ok, S::Error>
495where
496    S: Serializer,
497{
498    if let Some(value) = value {
499        serialize_bytes64(value, serializer)
500    } else {
501        serializer.serialize_none()
502    }
503}
504
505struct VecBytes32Deserializer;
506
507impl<'de> Visitor<'de> for VecBytes32Deserializer {
508    type Value = Vec<[u8; 32]>;
509
510    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
511        formatter.write_str("vector sequence.")
512    }
513
514    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
515    where
516        A: SeqAccess<'de>,
517    {
518        let mut ret = Vec::<[u8; 32]>::new();
519        while let Some(v) = seq.next_element::<H256>()? {
520            ret.push(v.to_fixed_bytes());
521        }
522        Ok(ret)
523    }
524}
525
526pub fn serialize_vec_bytes32<S>(value: &Vec<[u8; 32]>, serializer: S) -> Result<S::Ok, S::Error>
527where
528    S: Serializer,
529{
530    let mut seq = serializer.serialize_seq(Some(value.len()))?;
531    for e in value {
532        seq.serialize_element(&WrappedBytes32(*e))?;
533    }
534    seq.end()
535}
536
537pub fn deserialize_vec_bytes32<'de, D>(deserializer: D) -> Result<Vec<[u8; 32]>, D::Error>
538where
539    D: Deserializer<'de>,
540{
541    deserializer.deserialize_seq(VecBytes32Deserializer)
542}
543
544#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
545pub struct WrappedBytes20(
546    #[serde(
547        serialize_with = "serialize_bytes20",
548        deserialize_with = "deserialize_bytes20"
549    )]
550    pub [u8; 20],
551);
552
553struct VecBytes20Deserializer;
554
555impl<'de> Visitor<'de> for VecBytes20Deserializer {
556    type Value = Vec<[u8; 20]>;
557
558    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
559        formatter.write_str("vector sequence.")
560    }
561
562    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
563    where
564        A: SeqAccess<'de>,
565    {
566        let mut ret = Vec::<[u8; 20]>::new();
567        while let Some(v) = seq.next_element::<H160>()? {
568            ret.push(v.to_fixed_bytes());
569        }
570        Ok(ret)
571    }
572}
573
574pub fn serialize_vec_bytes20<S>(value: &Vec<[u8; 20]>, serializer: S) -> Result<S::Ok, S::Error>
575where
576    S: Serializer,
577{
578    let mut seq = serializer.serialize_seq(Some(value.len()))?;
579    for e in value {
580        seq.serialize_element(&WrappedBytes20(*e))?;
581    }
582    seq.end()
583}
584
585pub fn deserialize_vec_bytes20<'de, D>(deserializer: D) -> Result<Vec<[u8; 20]>, D::Error>
586where
587    D: Deserializer<'de>,
588{
589    deserializer.deserialize_seq(VecBytes20Deserializer)
590}
591
592pub fn serialize_f64<S>(value: &f64, serializer: S) -> Result<S::Ok, S::Error>
593where
594    S: Serializer,
595{
596    serializer.serialize_str(&value.to_string())
597}
598
599pub fn deserialize_f64<'de, D>(deserializer: D) -> Result<f64, D::Error>
600where
601    D: Deserializer<'de>,
602{
603    let s = String::deserialize(deserializer)?;
604    f64::from_str(&s).map_err(|_| D::Error::custom("invalid f64 value"))
605}
606
607#[derive(Clone, Debug, PartialEq, Deserialize, Serialize, Default)]
608pub struct WrappedF64(
609    #[serde(deserialize_with = "deserialize_f64", serialize_with = "serialize_f64")] pub f64,
610);
611
612pub fn serialize_option_f64<S>(value: &Option<f64>, serializer: S) -> Result<S::Ok, S::Error>
613where
614    S: Serializer,
615{
616    if let Some(value) = value {
617        serialize_f64(value, serializer)
618    } else {
619        serializer.serialize_none()
620    }
621}
622
623pub fn deserialize_option_f64<'de, D>(deserializer: D) -> Result<Option<f64>, D::Error>
624where
625    D: Deserializer<'de>,
626{
627    Option::<WrappedF64>::deserialize(deserializer)
628        .map(|opt_wrapped: Option<WrappedF64>| opt_wrapped.map(|wrapped: WrappedF64| wrapped.0))
629}
630
631pub fn str_or_i64<'de, D>(deserializer: D) -> Result<i64, D::Error>
632where
633    D: Deserializer<'de>,
634{
635    #[derive(Deserialize)]
636    #[serde(untagged)]
637    enum StrOrU64<'a> {
638        Str(&'a str),
639        I64(i64),
640    }
641    Ok(match StrOrU64::deserialize(deserializer)? {
642        StrOrU64::Str(v) => v.parse().unwrap_or(0), // Ignoring parsing errors
643        StrOrU64::I64(v) => v,
644    })
645}
vertex_sdk/vertex_utils/serialize_utils.rs

vertex_sdk/vertex_utils/
serialize_utils.rs
