1#[cfg(feature = "serialize")]
2use serde::{Serialize, Serializer, Deserialize, Deserializer};
3
4#[cfg(feature = "serialize")]
5use sophon_types_serialize;
6
7macro_rules! impl_serde {
8 ($name: ident, $len: expr) => {
9 #[cfg(feature = "serialize")]
10 impl Serialize for $name {
11 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
12 let mut slice = [0u8; 2 + 2 * $len * 8];
13 let mut bytes = [0u8; $len * 8];
14 self.to_big_endian(&mut bytes);
15 sophon_types_serialize::serialize_uint(&mut slice, &bytes, serializer)
16 }
17 }
18
19 #[cfg(feature = "serialize")]
20 impl<'de> Deserialize<'de> for $name {
21 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
22 let mut bytes = [0u8; $len * 8];
23 let wrote = sophon_types_serialize::deserialize_check_len(deserializer, sophon_types_serialize::ExpectedLen::Between(0, &mut bytes))?;
24 Ok(bytes[0..wrote].into())
25 }
26 }
27 }
28}
29
30construct_uint!(U64, 1);
31construct_uint!(U128, 2);
32construct_uint!(U256, 4);
33construct_uint!(U512, 8);
34
35impl_serde!(U64, 1);
36impl_serde!(U128, 2);
37impl_serde!(U256, 4);
38impl_serde!(U512, 8);
39
40impl U256 {
41 #[inline(always)]
44 pub fn full_mul(self, other: U256) -> U512 {
45 U512(uint_full_mul_reg!(U256, 4, self, other))
46 }
47}
48
49impl From<U256> for U512 {
50 fn from(value: U256) -> U512 {
51 let U256(ref arr) = value;
52 let mut ret = [0; 8];
53 ret[0] = arr[0];
54 ret[1] = arr[1];
55 ret[2] = arr[2];
56 ret[3] = arr[3];
57 U512(ret)
58 }
59}
60
61impl From<U512> for U256 {
62 fn from(value: U512) -> U256 {
63 let U512(ref arr) = value;
64 if arr[4] | arr[5] | arr[6] | arr[7] != 0 {
65 panic!("From<U512> for U256: encountered overflow")
66 }
67 let mut ret = [0; 4];
68 ret[0] = arr[0];
69 ret[1] = arr[1];
70 ret[2] = arr[2];
71 ret[3] = arr[3];
72 U256(ret)
73 }
74}
75
76impl<'a> From<&'a U256> for U512 {
77 fn from(value: &'a U256) -> U512 {
78 let U256(ref arr) = *value;
79 let mut ret = [0; 8];
80 ret[0] = arr[0];
81 ret[1] = arr[1];
82 ret[2] = arr[2];
83 ret[3] = arr[3];
84 U512(ret)
85 }
86}
87
88impl<'a> From<&'a U512> for U256 {
89 fn from(value: &'a U512) -> U256 {
90 let U512(ref arr) = *value;
91 if arr[4] | arr[5] | arr[6] | arr[7] != 0 {
92 panic!("From<&U512> for U256: encountered overflow")
93 }
94 let mut ret = [0; 4];
95 ret[0] = arr[0];
96 ret[1] = arr[1];
97 ret[2] = arr[2];
98 ret[3] = arr[3];
99 U256(ret)
100 }
101}
102
103impl From<U256> for U128 {
104 fn from(value: U256) -> U128 {
105 let U256(ref arr) = value;
106 if arr[2] | arr[3] != 0 {
107 panic!("From<U256> for U128: encountered overflow")
108 }
109 let mut ret = [0; 2];
110 ret[0] = arr[0];
111 ret[1] = arr[1];
112 U128(ret)
113 }
114}
115
116impl From<U512> for U128 {
117 fn from(value: U512) -> U128 {
118 let U512(ref arr) = value;
119 if arr[2] | arr[3] | arr[4] | arr[5] | arr[6] | arr[7] != 0 {
120 panic!("From<U512> for U128: encountered overflow")
121 }
122 let mut ret = [0; 2];
123 ret[0] = arr[0];
124 ret[1] = arr[1];
125 U128(ret)
126 }
127}
128
129impl From<U128> for U512 {
130 fn from(value: U128) -> U512 {
131 let U128(ref arr) = value;
132 let mut ret = [0; 8];
133 ret[0] = arr[0];
134 ret[1] = arr[1];
135 U512(ret)
136 }
137}
138
139impl From<U128> for U256 {
140 fn from(value: U128) -> U256 {
141 let U128(ref arr) = value;
142 let mut ret = [0; 4];
143 ret[0] = arr[0];
144 ret[1] = arr[1];
145 U256(ret)
146 }
147}
148
149impl From<U256> for u64 {
150 fn from(value: U256) -> u64 {
151 value.as_u64()
152 }
153}
154
155impl From<U256> for u32 {
156 fn from(value: U256) -> u32 {
157 value.as_u32()
158 }
159}
160
161#[cfg(test)]
162mod tests {
163 use super::{U256, U512};
164 use std::u64::MAX;
165 use serde_json as ser;
166
167 macro_rules! test_serialize {
168 ($name: ident, $test_name: ident) => {
169 #[test]
170 fn $test_name() {
171 let tests = vec![
172 ($name::from(0), "0x0"),
173 ($name::from(1), "0x1"),
174 ($name::from(2), "0x2"),
175 ($name::from(10), "0xa"),
176 ($name::from(15), "0xf"),
177 ($name::from(15), "0xf"),
178 ($name::from(16), "0x10"),
179 ($name::from(1_000), "0x3e8"),
180 ($name::from(100_000), "0x186a0"),
181 ($name::from(u64::max_value()), "0xffffffffffffffff"),
182 ($name::from(u64::max_value()) + 1, "0x10000000000000000"),
183 ];
184
185 for (number, expected) in tests {
186 assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number).unwrap());
187 assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
188 }
189
190 assert!(ser::from_str::<$name>("\"∀∂\"").unwrap_err().is_data());
192 assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data());
193 assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
194 assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data());
195 assert!(ser::from_str::<$name>("\"10\"").unwrap_err().is_data());
196 assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data());
197 }
198 }
199 }
200
201 test_serialize!(U256, test_u256);
202 test_serialize!(U512, test_u512);
203
204 #[test]
205 fn test_serialize_large_values() {
206 assert_eq!(
207 ser::to_string_pretty(&!U256::zero()).unwrap(),
208 "\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
209 );
210 assert!(
211 ser::from_str::<U256>("\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"").unwrap_err().is_data()
212 );
213 }
214
215 #[test]
216 fn fixed_arrays_roundtrip() {
217 let raw: U256 = "7094875209347850239487502394881".into();
218 let array: [u8; 32] = raw.into();
219 let new_raw = array.into();
220
221 assert_eq!(raw, new_raw);
222 }
223
224 #[test]
225 fn u256_multi_full_mul() {
226 let result = U256([0, 0, 0, 0]).full_mul(U256([0, 0, 0, 0]));
227 assert_eq!(U512([0, 0, 0, 0, 0, 0, 0, 0]), result);
228
229 let result = U256([1, 0, 0, 0]).full_mul(U256([1, 0, 0, 0]));
230 assert_eq!(U512([1, 0, 0, 0, 0, 0, 0, 0]), result);
231
232 let result = U256([5, 0, 0, 0]).full_mul(U256([5, 0, 0, 0]));
233 assert_eq!(U512([25, 0, 0, 0, 0, 0, 0, 0]), result);
234
235 let result = U256([0, 5, 0, 0]).full_mul(U256([0, 5, 0, 0]));
236 assert_eq!(U512([0, 0, 25, 0, 0, 0, 0, 0]), result);
237
238 let result = U256([0, 0, 0, 4]).full_mul(U256([4, 0, 0, 0]));
239 assert_eq!(U512([0, 0, 0, 16, 0, 0, 0, 0]), result);
240
241 let result = U256([0, 0, 0, 5]).full_mul(U256([2, 0, 0, 0]));
242 assert_eq!(U512([0, 0, 0, 10, 0, 0, 0, 0]), result);
243
244 let result = U256([0, 0, 2, 0]).full_mul(U256([0, 5, 0, 0]));
245 assert_eq!(U512([0, 0, 0, 10, 0, 0, 0, 0]), result);
246
247 let result = U256([0, 3, 0, 0]).full_mul(U256([0, 0, 3, 0]));
248 assert_eq!(U512([0, 0, 0, 9, 0, 0, 0, 0]), result);
249
250 let result = U256([0, 0, 8, 0]).full_mul(U256([0, 0, 6, 0]));
251 assert_eq!(U512([0, 0, 0, 0, 48, 0, 0, 0]), result);
252
253 let result = U256([9, 0, 0, 0]).full_mul(U256([0, 3, 0, 0]));
254 assert_eq!(U512([0, 27, 0, 0, 0, 0, 0, 0]), result);
255
256 let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, 0, 0, 0]));
257 assert_eq!(U512([1, MAX-1, 0, 0, 0, 0, 0, 0]), result);
258
259 let result = U256([0, MAX, 0, 0]).full_mul(U256([MAX, 0, 0, 0]));
260 assert_eq!(U512([0, 1, MAX-1, 0, 0, 0, 0, 0]), result);
261
262 let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, 0, 0, 0]));
263 assert_eq!(U512([1, MAX, MAX-1, 0, 0, 0, 0, 0]), result);
264
265 let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, MAX, 0, 0]));
266 assert_eq!(U512([1, MAX, MAX-1, 0, 0, 0, 0, 0]), result);
267
268 let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, MAX, 0, 0]));
269 assert_eq!(U512([1, 0, MAX-1, MAX, 0, 0, 0, 0]), result);
270
271 let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, MAX, MAX, 0]));
272 assert_eq!(U512([1, MAX, MAX, MAX-1, 0, 0, 0, 0]), result);
273
274 let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, 0, 0, 0]));
275 assert_eq!(U512([1, MAX, MAX, MAX-1, 0, 0, 0, 0]), result);
276
277 let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, MAX, MAX, MAX]));
278 assert_eq!(U512([1, MAX, MAX, MAX, MAX-1, 0, 0, 0]), result);
279
280 let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, 0, 0, 0]));
281 assert_eq!(U512([1, MAX, MAX, MAX, MAX-1, 0, 0, 0]), result);
282
283 let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, MAX, 0, 0]));
284 assert_eq!(U512([1, 0, MAX, MAX-1, MAX, 0, 0, 0]), result);
285
286 let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, MAX, MAX, 0]));
287 assert_eq!(U512([1, 0, MAX, MAX-1, MAX, 0, 0, 0]), result);
288
289 let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, MAX, 0, 0]));
290 assert_eq!(U512([1, 0, MAX, MAX, MAX-1, MAX, 0, 0]), result);
291
292 let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, MAX, MAX, MAX]));
293 assert_eq!(U512([1, 0, MAX, MAX, MAX-1, MAX, 0, 0]), result);
294
295 let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, MAX, MAX, 0]));
296 assert_eq!(U512([1, 0, 0, MAX-1, MAX, MAX, 0, 0]), result);
297
298 let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, MAX, MAX, MAX]));
299 assert_eq!(U512([1, 0, 0, MAX, MAX-1, MAX, MAX, 0]), result);
300
301 let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, MAX, MAX, 0]));
302 assert_eq!(U512([1, 0, 0, MAX, MAX-1, MAX, MAX, 0]), result);
303
304 let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, MAX, MAX, MAX]));
305 assert_eq!(U512([1, 0, 0, 0, MAX-1, MAX, MAX, MAX]), result);
306
307 let result = U256([0, 0, 0, MAX]).full_mul(U256([0, 0, 0, MAX]));
308 assert_eq!(U512([0, 0, 0, 0, 0, 0, 1, MAX-1]), result);
309
310 let result = U256([1, 0, 0, 0]).full_mul(U256([0, 0, 0, MAX]));
311 assert_eq!(U512([0, 0, 0, MAX, 0, 0, 0, 0]), result);
312
313 let result = U256([1, 2, 3, 4]).full_mul(U256([5, 0, 0, 0]));
314 assert_eq!(U512([5, 10, 15, 20, 0, 0, 0, 0]), result);
315
316 let result = U256([1, 2, 3, 4]).full_mul(U256([0, 6, 0, 0]));
317 assert_eq!(U512([0, 6, 12, 18, 24, 0, 0, 0]), result);
318
319 let result = U256([1, 2, 3, 4]).full_mul(U256([0, 0, 7, 0]));
320 assert_eq!(U512([0, 0, 7, 14, 21, 28, 0, 0]), result);
321
322 let result = U256([1, 2, 3, 4]).full_mul(U256([0, 0, 0, 8]));
323 assert_eq!(U512([0, 0, 0, 8, 16, 24, 32, 0]), result);
324
325 let result = U256([1, 2, 3, 4]).full_mul(U256([5, 6, 7, 8]));
326 assert_eq!(U512([5, 16, 34, 60, 61, 52, 32, 0]), result);
327 }
328}