s_types/
uint.rs

1#[cfg(feature="serialize")]
2use serde::{Serialize, Serializer, Deserialize, Deserializer};
3
4#[cfg(feature="serialize")]
5use s_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				s_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 = s_types_serialize::deserialize_check_len(deserializer, s_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	/// Multiplies two 256-bit integers to produce full 512-bit integer
42	/// No overflow possible
43	#[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!("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!("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!("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!("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				// Invalid examples
191				assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data());
192				assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
193				assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data());
194				assert!(ser::from_str::<$name>("\"10\"").unwrap_err().is_data());
195				assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data());
196			}
197		}
198	}
199
200	test_serialize!(U256, test_u256);
201	test_serialize!(U512, test_u512);
202
203	#[test]
204	fn test_serialize_large_values() {
205		assert_eq!(
206			ser::to_string_pretty(&!U256::zero()).unwrap(),
207			"\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
208		);
209		assert!(
210			ser::from_str::<U256>("\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"").unwrap_err().is_data()
211		);
212	}
213
214	#[test]
215	fn fixed_arrays_roundtrip() {
216		let raw: U256 = "7094875209347850239487502394881".into();
217		let array: [u8; 32] = raw.into();
218		let new_raw = array.into();
219
220		assert_eq!(raw, new_raw);
221	}
222
223	#[test]
224	fn u256_multi_full_mul() {
225		let result = U256([0, 0, 0, 0]).full_mul(U256([0, 0, 0, 0]));
226		assert_eq!(U512([0, 0, 0, 0, 0, 0, 0, 0]), result);
227
228		let result = U256([1, 0, 0, 0]).full_mul(U256([1, 0, 0, 0]));
229		assert_eq!(U512([1, 0, 0, 0, 0, 0, 0, 0]), result);
230
231		let result = U256([5, 0, 0, 0]).full_mul(U256([5, 0, 0, 0]));
232		assert_eq!(U512([25, 0, 0, 0, 0, 0, 0, 0]), result);
233
234		let result = U256([0, 5, 0, 0]).full_mul(U256([0, 5, 0, 0]));
235		assert_eq!(U512([0, 0, 25, 0, 0, 0, 0, 0]), result);
236
237		let result = U256([0, 0, 0, 4]).full_mul(U256([4, 0, 0, 0]));
238		assert_eq!(U512([0, 0, 0, 16, 0, 0, 0, 0]), result);
239
240		let result = U256([0, 0, 0, 5]).full_mul(U256([2, 0, 0, 0]));
241		assert_eq!(U512([0, 0, 0, 10, 0, 0, 0, 0]), result);
242
243		let result = U256([0, 0, 2, 0]).full_mul(U256([0, 5, 0, 0]));
244		assert_eq!(U512([0, 0, 0, 10, 0, 0, 0, 0]), result);
245
246		let result = U256([0, 3, 0, 0]).full_mul(U256([0, 0, 3, 0]));
247		assert_eq!(U512([0, 0, 0, 9, 0, 0, 0, 0]), result);
248
249		let result = U256([0, 0, 8, 0]).full_mul(U256([0, 0, 6, 0]));
250		assert_eq!(U512([0, 0, 0, 0, 48, 0, 0, 0]), result);
251
252		let result = U256([9, 0, 0, 0]).full_mul(U256([0, 3, 0, 0]));
253		assert_eq!(U512([0, 27, 0, 0, 0, 0, 0, 0]), result);
254
255		let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, 0, 0, 0]));
256		assert_eq!(U512([1, MAX-1, 0, 0, 0, 0, 0, 0]), result);
257
258		let result = U256([0, MAX, 0, 0]).full_mul(U256([MAX, 0, 0, 0]));
259		assert_eq!(U512([0, 1, MAX-1, 0, 0, 0, 0, 0]), result);
260
261		let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, 0, 0, 0]));
262		assert_eq!(U512([1, MAX, MAX-1, 0, 0, 0, 0, 0]), result);
263
264		let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, MAX, 0, 0]));
265		assert_eq!(U512([1, MAX, MAX-1, 0, 0, 0, 0, 0]), result);
266
267		let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, MAX, 0, 0]));
268		assert_eq!(U512([1, 0, MAX-1, MAX, 0, 0, 0, 0]), result);
269
270		let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, MAX, MAX, 0]));
271		assert_eq!(U512([1, MAX, MAX, MAX-1, 0, 0, 0, 0]), result);
272
273		let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, 0, 0, 0]));
274		assert_eq!(U512([1, MAX, MAX, MAX-1, 0, 0, 0, 0]), result);
275
276		let result = U256([MAX, 0, 0, 0]).full_mul(U256([MAX, MAX, MAX, MAX]));
277		assert_eq!(U512([1, MAX, MAX, MAX, MAX-1, 0, 0, 0]), result);
278
279		let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, 0, 0, 0]));
280		assert_eq!(U512([1, MAX, MAX, MAX, MAX-1, 0, 0, 0]), result);
281
282		let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, MAX, 0, 0]));
283		assert_eq!(U512([1, 0, MAX, MAX-1, MAX, 0, 0, 0]), result);
284
285		let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, MAX, MAX, 0]));
286		assert_eq!(U512([1, 0, MAX, MAX-1, MAX, 0, 0, 0]), result);
287
288		let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, MAX, 0, 0]));
289		assert_eq!(U512([1, 0, MAX, MAX, MAX-1, MAX, 0, 0]), result);
290
291		let result = U256([MAX, MAX, 0, 0]).full_mul(U256([MAX, MAX, MAX, MAX]));
292		assert_eq!(U512([1, 0, MAX, MAX, MAX-1, MAX, 0, 0]), result);
293
294		let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, MAX, MAX, 0]));
295		assert_eq!(U512([1, 0, 0, MAX-1, MAX, MAX, 0, 0]), result);
296
297		let result = U256([MAX, MAX, MAX, 0]).full_mul(U256([MAX, MAX, MAX, MAX]));
298		assert_eq!(U512([1, 0, 0, MAX,	MAX-1, MAX, MAX, 0]), result);
299
300		let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, MAX, MAX, 0]));
301		assert_eq!(U512([1, 0, 0, MAX,	MAX-1, MAX, MAX, 0]), result);
302
303		let result = U256([MAX, MAX, MAX, MAX]).full_mul(U256([MAX, MAX, MAX, MAX]));
304		assert_eq!(U512([1, 0, 0, 0, MAX-1, MAX, MAX, MAX]), result);
305
306		let result = U256([0, 0, 0, MAX]).full_mul(U256([0, 0, 0, MAX]));
307		assert_eq!(U512([0, 0, 0, 0, 0, 0, 1, MAX-1]), result);
308
309		let result = U256([1, 0, 0, 0]).full_mul(U256([0, 0, 0, MAX]));
310		assert_eq!(U512([0, 0, 0, MAX, 0, 0, 0, 0]), result);
311
312		let result = U256([1, 2, 3, 4]).full_mul(U256([5, 0, 0, 0]));
313		assert_eq!(U512([5, 10, 15, 20, 0, 0, 0, 0]), result);
314
315		let result = U256([1, 2, 3, 4]).full_mul(U256([0, 6, 0, 0]));
316		assert_eq!(U512([0, 6, 12, 18, 24, 0, 0, 0]), result);
317
318		let result = U256([1, 2, 3, 4]).full_mul(U256([0, 0, 7, 0]));
319		assert_eq!(U512([0, 0, 7, 14, 21, 28, 0, 0]), result);
320
321		let result = U256([1, 2, 3, 4]).full_mul(U256([0, 0, 0, 8]));
322		assert_eq!(U512([0, 0, 0, 8, 16, 24, 32, 0]), result);
323
324		let result = U256([1, 2, 3, 4]).full_mul(U256([5, 6, 7, 8]));
325		assert_eq!(U512([5, 16, 34, 60, 61, 52, 32, 0]), result);
326	}
327}
s_types/uint.rs

s_types/
uint.rs
