near_api_types/json/
integers.rs

1use borsh::{BorshDeserialize, BorshSerialize};
2use serde::{Deserialize, Deserializer, Serialize};
3use std::fmt;
4
5#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize, Serialize)]
6pub struct U64(pub u64);
7
8#[derive(Debug, Clone, PartialEq, Eq, BorshSerialize, BorshDeserialize, Serialize)]
9pub struct U128(pub u128);
10
11impl From<u64> for U64 {
12    fn from(value: u64) -> Self {
13        Self(value)
14    }
15}
16
17impl From<u128> for U128 {
18    fn from(value: u128) -> Self {
19        Self(value)
20    }
21}
22
23impl<'de> Deserialize<'de> for U64 {
24    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
25    where
26        D: Deserializer<'de>,
27    {
28        struct StringOrNumberVisitor;
29
30        impl serde::de::Visitor<'_> for StringOrNumberVisitor {
31            type Value = U64;
32
33            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
34                formatter.write_str("a string or a number")
35            }
36
37            fn visit_str<E>(self, value: &str) -> Result<U64, E>
38            where
39                E: serde::de::Error,
40            {
41                value
42                    .parse::<u64>()
43                    .map(U64)
44                    .map_err(serde::de::Error::custom)
45            }
46
47            fn visit_u64<E>(self, value: u64) -> Result<U64, E>
48            where
49                E: serde::de::Error,
50            {
51                Ok(U64(value))
52            }
53        }
54
55        deserializer.deserialize_any(StringOrNumberVisitor)
56    }
57}
58
59impl<'de> Deserialize<'de> for U128 {
60    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
61    where
62        D: Deserializer<'de>,
63    {
64        struct StringOrNumberVisitor;
65
66        impl serde::de::Visitor<'_> for StringOrNumberVisitor {
67            type Value = U128;
68
69            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
70                formatter.write_str("a string or a number 128")
71            }
72
73            fn visit_str<E>(self, value: &str) -> Result<U128, E>
74            where
75                E: serde::de::Error,
76            {
77                value
78                    .parse::<u128>()
79                    .map(U128)
80                    .map_err(serde::de::Error::custom)
81            }
82
83            fn visit_u64<E>(self, value: u64) -> Result<U128, E>
84            where
85                E: serde::de::Error,
86            {
87                Ok(U128(value as u128))
88            }
89
90            fn visit_u128<E>(self, value: u128) -> Result<U128, E>
91            where
92                E: serde::de::Error,
93            {
94                Ok(U128(value))
95            }
96        }
97
98        deserializer.deserialize_any(StringOrNumberVisitor)
99    }
100}
101
102#[cfg(test)]
103mod tests {
104    use super::*;
105    use borsh::BorshDeserialize;
106
107    #[test]
108    fn test_u64_struct_from_u64() {
109        let u64_value = 1234567890;
110        let u64_from_u64: U64 = u64_value.into();
111
112        assert_eq!(u64_from_u64.0, u64_value);
113    }
114
115    #[test]
116    fn test_u128_struct_from_u128() {
117        let u128_value = 12345678901234567890;
118        let u128_from_u128: U128 = u128_value.into();
119
120        assert_eq!(u128_from_u128.0, u128_value);
121    }
122
123    #[test]
124    fn test_u64_struct_from_u128() {
125        let u128_value = 12345678901234567890;
126        let u64_from_u128: U64 = u128_value.into();
127
128        assert_eq!(u64_from_u128.0, u128_value);
129    }
130
131    #[test]
132    fn test_u128_struct_from_u64() {
133        let u64_value = 1234567890;
134        let u128_from_u64: U128 = u64_value.into();
135
136        assert_eq!(u128_from_u64.0, u64_value);
137    }
138
139    #[test]
140    fn test_u64_serde() {
141        let u64_value = U64(1234567890);
142        let serialized = serde_json::to_string(&u64_value).unwrap();
143
144        assert_eq!(serialized, "1234567890");
145    }
146
147    #[test]
148    fn test_u128_serde() {
149        let u128_value = U128(12345678901234567890);
150        let serialized = serde_json::to_string(&u128_value).unwrap();
151
152        assert_eq!(serialized, "12345678901234567890");
153    }
154
155    #[test]
156    fn test_u64_from_str() {
157        let u64_value = "12345678901234567890";
158        let deserialized: U64 = serde_json::from_str(u64_value).unwrap();
159
160        assert_eq!(deserialized, U64(12345678901234567890));
161    }
162
163    #[test]
164    fn test_u128_from_str() {
165        let u128_value = "12345678901234567890";
166        let deserialized: U128 = serde_json::from_str(u128_value).unwrap();
167
168        assert_eq!(deserialized, U128(12345678901234567890));
169    }
170
171    #[test]
172    fn test_u64_de_serde() {
173        let u64_value = 1234567890;
174        let u64_value_str = format!("\"{u64_value}\"");
175        let deserialized: U64 = serde_json::from_str(&u64_value_str).unwrap();
176
177        assert_eq!(deserialized.0, u64_value);
178    }
179
180    #[test]
181    fn test_u128_de_serde() {
182        let u128_value = 12345678901234567890;
183        let u128_value_str = format!("\"{u128_value}\"");
184        let deserialized: U128 = serde_json::from_str(&u128_value_str).unwrap();
185
186        assert_eq!(deserialized.0, u128_value);
187    }
188
189    #[test]
190    fn test_u64_borsh() {
191        let u64_value = U64(1234567890);
192        let serialized = borsh::to_vec(&u64_value).unwrap();
193        let deserialized = U64::try_from_slice(&serialized).unwrap();
194
195        assert_eq!(deserialized, u64_value);
196    }
197
198    #[test]
199    fn test_u128_borsh() {
200        let u128_value = U128(12345678901234567890u128);
201        let serialized = borsh::to_vec(&u128_value).unwrap();
202        let deserialized = U128::try_from_slice(&serialized).unwrap();
203
204        assert_eq!(deserialized, u128_value);
205    }
206}
near_api_types/json/integers.rs

near_api_types/json/
integers.rs
