Skip to main content

jupiter_sdk/
types.rs

1use serde::{Deserialize, Deserializer, Serialize};
2use std::fmt;
3
4
5
6#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize)]
7pub struct U128(pub u128);
8
9impl<'de> Deserialize<'de> for U128 {
10    fn deserialize<D>(de: D) -> Result<Self, D::Error>
11    where
12        D: Deserializer<'de>,
13    {
14        struct V;
15        impl<'de> serde::de::Visitor<'de> for V {
16            type Value = U128;
17            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
18                f.write_str("u128 or string")
19            }
20            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> { Ok(U128(v as u128)) }
21            fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> { Ok(U128(v)) }
22            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
23            where E: serde::de::Error {
24                if v < 0 { return Err(E::custom("negative not allowed")); }
25                Ok(U128(v as u128))
26            }
27            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
28            where E: serde::de::Error {
29                if v < 0.0 { return Err(E::custom("negative not allowed")); }
30                Ok(U128(v as u128))
31            }
32            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
33            where E: serde::de::Error {
34                s.parse::<u128>().map(U128).map_err(E::custom)
35            }
36        }
37        de.deserialize_any(V)
38    }
39}
40
41impl fmt::Display for U128 {
42    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
43        write!(f, "{}", self.0)
44    }
45}
46
47
48
49
50#[derive(Debug, Clone, Copy, PartialEq, Serialize)]
51pub struct F64(pub f64);
52
53impl<'de> Deserialize<'de> for F64 {
54    fn deserialize<D>(de: D) -> Result<Self, D::Error>
55    where
56        D: Deserializer<'de>,
57    {
58        struct V;
59        impl<'de> serde::de::Visitor<'de> for V {
60            type Value = F64;
61            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
62                f.write_str("f64 or string")
63            }
64            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E> { Ok(F64(v)) }
65            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> { Ok(F64(v as f64)) }
66            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> { Ok(F64(v as f64)) }
67            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
68            where E: serde::de::Error {
69                s.parse::<f64>().map(F64).map_err(E::custom)
70            }
71        }
72        de.deserialize_any(V)
73    }
74}
75
76impl fmt::Display for F64 {
77    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
78        write!(f, "{}", self.0)
79    }
80}