1use ark_std::{
2 borrow::Cow,
3 collections::{BTreeMap, BTreeSet},
4 io::{Read, Write},
5 marker::PhantomData,
6 rc::Rc,
7 string::String,
8 vec::Vec,
9};
10use num_bigint::BigUint;
11
12use crate::*;
13
14impl Valid for bool {
15 fn check(&self) -> Result<(), SerializationError> {
16 Ok(())
17 }
18}
19
20impl CanonicalSerialize for bool {
21 #[inline]
22 fn serialize_with_mode<W: Write>(
23 &self,
24 mut writer: W,
25 _compress: Compress,
26 ) -> Result<(), SerializationError> {
27 writer.write(&[*self as u8])?;
28 Ok(())
29 }
30
31 #[inline]
32 fn serialized_size(&self, _compress: Compress) -> usize {
33 1
34 }
35}
36
37impl CanonicalDeserialize for bool {
38 #[inline]
39 fn deserialize_with_mode<R: Read>(
40 reader: R,
41 compress: Compress,
42 validate: Validate,
43 ) -> Result<Self, SerializationError> {
44 match u8::deserialize_with_mode(reader, compress, validate)? {
45 0u8 => Ok(false),
46 1u8 => Ok(true),
47 _ => Err(SerializationError::InvalidData),
48 }
49 }
50}
51
52macro_rules! impl_uint {
53 ($type:ty) => {
54 impl CanonicalSerialize for $type {
55 #[inline]
56 fn serialize_with_mode<W: Write>(
57 &self,
58 mut writer: W,
59 _compress: Compress,
60 ) -> Result<(), SerializationError> {
61 Ok(writer.write_all(&self.to_le_bytes())?)
62 }
63
64 #[inline]
65 fn serialized_size(&self, _compress: Compress) -> usize {
66 core::mem::size_of::<$type>()
67 }
68 }
69
70 impl Valid for $type {
71 #[inline]
72 fn check(&self) -> Result<(), SerializationError> {
73 Ok(())
74 }
75
76 #[inline]
77 fn batch_check<'a>(
78 _batch: impl Iterator<Item = &'a Self>,
79 ) -> Result<(), SerializationError>
80 where
81 Self: 'a,
82 {
83 Ok(())
84 }
85 }
86
87 impl CanonicalDeserialize for $type {
88 #[inline]
89 fn deserialize_with_mode<R: Read>(
90 mut reader: R,
91 _compress: Compress,
92 _validate: Validate,
93 ) -> Result<Self, SerializationError> {
94 let mut bytes = [0u8; core::mem::size_of::<$type>()];
95 reader.read_exact(&mut bytes)?;
96 Ok(<$type>::from_le_bytes(bytes))
97 }
98 }
99 };
100}
101
102impl_uint!(u8);
103impl_uint!(u16);
104impl_uint!(u32);
105impl_uint!(u64);
106
107impl CanonicalSerialize for usize {
108 #[inline]
109 fn serialize_with_mode<W: Write>(
110 &self,
111 mut writer: W,
112 _compress: Compress,
113 ) -> Result<(), SerializationError> {
114 Ok(writer.write_all(&(*self as u64).to_le_bytes())?)
115 }
116
117 #[inline]
118 fn serialized_size(&self, _compress: Compress) -> usize {
119 core::mem::size_of::<u64>()
120 }
121}
122
123impl Valid for usize {
124 #[inline]
125 fn check(&self) -> Result<(), SerializationError> {
126 Ok(())
127 }
128
129 #[inline]
130 fn batch_check<'a>(_batch: impl Iterator<Item = &'a Self>) -> Result<(), SerializationError>
131 where
132 Self: 'a,
133 {
134 Ok(())
135 }
136}
137
138impl CanonicalDeserialize for usize {
139 #[inline]
140 fn deserialize_with_mode<R: Read>(
141 mut reader: R,
142 _compress: Compress,
143 _validate: Validate,
144 ) -> Result<Self, SerializationError> {
145 let mut bytes = [0u8; core::mem::size_of::<u64>()];
146 reader.read_exact(&mut bytes)?;
147 Ok(<u64>::from_le_bytes(bytes) as usize)
148 }
149}
150
151impl CanonicalSerialize for BigUint {
152 #[inline]
153 fn serialize_with_mode<W: Write>(
154 &self,
155 writer: W,
156 compress: Compress,
157 ) -> Result<(), SerializationError> {
158 self.to_bytes_le().serialize_with_mode(writer, compress)
159 }
160
161 #[inline]
162 fn serialized_size(&self, compress: Compress) -> usize {
163 self.to_bytes_le().serialized_size(compress)
164 }
165}
166
167impl CanonicalDeserialize for BigUint {
168 #[inline]
169 fn deserialize_with_mode<R: Read>(
170 reader: R,
171 compress: Compress,
172 validate: Validate,
173 ) -> Result<Self, SerializationError> {
174 Ok(BigUint::from_bytes_le(&Vec::<u8>::deserialize_with_mode(
175 reader, compress, validate,
176 )?))
177 }
178}
179
180impl Valid for BigUint {
181 #[inline]
182 fn check(&self) -> Result<(), SerializationError> {
183 Ok(())
184 }
185
186 #[inline]
187 fn batch_check<'a>(_batch: impl Iterator<Item = &'a Self>) -> Result<(), SerializationError>
188 where
189 Self: 'a,
190 {
191 Ok(())
192 }
193}
194
195impl<T: CanonicalSerialize> CanonicalSerialize for Option<T> {
196 #[inline]
197 fn serialize_with_mode<W: Write>(
198 &self,
199 mut writer: W,
200 compress: Compress,
201 ) -> Result<(), SerializationError> {
202 self.is_some().serialize_with_mode(&mut writer, compress)?;
203 if let Some(item) = self {
204 item.serialize_with_mode(&mut writer, compress)?;
205 }
206
207 Ok(())
208 }
209
210 #[inline]
211 fn serialized_size(&self, compress: Compress) -> usize {
212 1 + self
213 .as_ref()
214 .map(|s| s.serialized_size(compress))
215 .unwrap_or(0)
216 }
217}
218
219impl<T: Valid> Valid for Option<T> {
220 #[inline]
221 fn check(&self) -> Result<(), SerializationError> {
222 match self {
223 Some(v) => v.check(),
224 None => Ok(()),
225 }
226 }
227
228 #[inline]
229 fn batch_check<'a>(
230 batch: impl Iterator<Item = &'a Self> + Send,
231 ) -> Result<(), SerializationError>
232 where
233 Self: 'a,
234 {
235 T::batch_check(batch.map(Option::as_ref).filter(Option::is_some).flatten())
236 }
237}
238
239impl<T: CanonicalDeserialize> CanonicalDeserialize for Option<T> {
240 #[inline]
241 fn deserialize_with_mode<R: Read>(
242 mut reader: R,
243 compress: Compress,
244 validate: Validate,
245 ) -> Result<Self, SerializationError> {
246 let is_some = bool::deserialize_with_mode(&mut reader, compress, validate)?;
247 let data = if is_some {
248 Some(T::deserialize_with_mode(&mut reader, compress, validate)?)
249 } else {
250 None
251 };
252
253 Ok(data)
254 }
255}
256
257impl<T> CanonicalSerialize for PhantomData<T> {
259 #[inline]
260 fn serialize_with_mode<W: Write>(
261 &self,
262 _writer: W,
263 _compress: Compress,
264 ) -> Result<(), SerializationError> {
265 Ok(())
266 }
267
268 #[inline]
269 fn serialized_size(&self, _compress: Compress) -> usize {
270 0
271 }
272}
273
274impl<T: Sync> Valid for PhantomData<T> {
275 #[inline]
276 fn check(&self) -> Result<(), SerializationError> {
277 Ok(())
278 }
279}
280
281impl<T: Send + Sync> CanonicalDeserialize for PhantomData<T> {
282 #[inline]
283 fn deserialize_with_mode<R: Read>(
284 _reader: R,
285 _compress: Compress,
286 _validate: Validate,
287 ) -> Result<Self, SerializationError> {
288 Ok(PhantomData)
289 }
290}
291
292impl<T: CanonicalSerialize + ToOwned> CanonicalSerialize for Rc<T> {
293 #[inline]
294 fn serialize_with_mode<W: Write>(
295 &self,
296 mut writer: W,
297 compress: Compress,
298 ) -> Result<(), SerializationError> {
299 self.as_ref().serialize_with_mode(&mut writer, compress)
300 }
301
302 #[inline]
303 fn serialized_size(&self, compress: Compress) -> usize {
304 self.as_ref().serialized_size(compress)
305 }
306}
307
308#[cfg(feature = "std")]
309impl<T: CanonicalSerialize + ToOwned> CanonicalSerialize for ark_std::sync::Arc<T> {
310 #[inline]
311 fn serialize_with_mode<W: Write>(
312 &self,
313 mut writer: W,
314 compress: Compress,
315 ) -> Result<(), SerializationError> {
316 self.as_ref().serialize_with_mode(&mut writer, compress)
317 }
318
319 #[inline]
320 fn serialized_size(&self, compress: Compress) -> usize {
321 self.as_ref().serialized_size(compress)
322 }
323}
324
325#[cfg(feature = "std")]
326impl<T: Valid + Sync + Send> Valid for ark_std::sync::Arc<T> {
327 #[inline]
328 fn check(&self) -> Result<(), SerializationError> {
329 self.as_ref().check()
330 }
331
332 #[inline]
333
334 fn batch_check<'a>(
335 batch: impl Iterator<Item = &'a Self> + Send,
336 ) -> Result<(), SerializationError>
337 where
338 Self: 'a,
339 {
340 T::batch_check(batch.map(|v| v.as_ref()))
341 }
342}
343
344#[cfg(feature = "std")]
345impl<T: CanonicalDeserialize + ToOwned + Sync + Send> CanonicalDeserialize
346 for ark_std::sync::Arc<T>
347{
348 #[inline]
349 fn deserialize_with_mode<R: Read>(
350 reader: R,
351 compress: Compress,
352 validate: Validate,
353 ) -> Result<Self, SerializationError> {
354 Ok(ark_std::sync::Arc::new(T::deserialize_with_mode(
355 reader, compress, validate,
356 )?))
357 }
358}
359
360impl<'a, T: CanonicalSerialize + ToOwned> CanonicalSerialize for Cow<'a, T> {
361 #[inline]
362 fn serialize_with_mode<W: Write>(
363 &self,
364 mut writer: W,
365 compress: Compress,
366 ) -> Result<(), SerializationError> {
367 self.as_ref().serialize_with_mode(&mut writer, compress)
368 }
369
370 #[inline]
371 fn serialized_size(&self, compress: Compress) -> usize {
372 self.as_ref().serialized_size(compress)
373 }
374}
375
376impl<'b, T> Valid for Cow<'b, T>
377where
378 T: ToOwned + Sync + Valid + Send,
379 <T as ToOwned>::Owned: CanonicalDeserialize + Send,
380{
381 #[inline]
382 fn check(&self) -> Result<(), SerializationError> {
383 <<T as ToOwned>::Owned>::check(&self.as_ref().to_owned())
384 }
385
386 #[inline]
387
388 fn batch_check<'a>(
389 batch: impl Iterator<Item = &'a Self> + Send,
390 ) -> Result<(), SerializationError>
391 where
392 Self: 'a,
393 {
394 let t: Vec<_> = batch.map(|v| v.as_ref().to_owned()).collect();
395 <<T as ToOwned>::Owned>::batch_check(t.iter())
396 }
397}
398
399impl<'a, T> CanonicalDeserialize for Cow<'a, T>
400where
401 T: ToOwned + Valid + Valid + Sync + Send,
402 <T as ToOwned>::Owned: CanonicalDeserialize + Valid + Send,
403{
404 #[inline]
405 fn deserialize_with_mode<R: Read>(
406 reader: R,
407 compress: Compress,
408 validate: Validate,
409 ) -> Result<Self, SerializationError> {
410 Ok(Cow::Owned(<T as ToOwned>::Owned::deserialize_with_mode(
411 reader, compress, validate,
412 )?))
413 }
414}
415
416impl<T: CanonicalSerialize, const N: usize> CanonicalSerialize for [T; N] {
417 #[inline]
418 fn serialize_with_mode<W: Write>(
419 &self,
420 mut writer: W,
421 compress: Compress,
422 ) -> Result<(), SerializationError> {
423 for item in self.iter() {
424 item.serialize_with_mode(&mut writer, compress)?;
425 }
426 Ok(())
427 }
428
429 #[inline]
430 fn serialized_size(&self, compress: Compress) -> usize {
431 self.iter()
432 .map(|item| item.serialized_size(compress))
433 .sum::<usize>()
434 }
435}
436impl<T: CanonicalDeserialize, const N: usize> Valid for [T; N] {
437 #[inline]
438 fn check(&self) -> Result<(), SerializationError> {
439 T::batch_check(self.iter())
440 }
441
442 #[inline]
443 fn batch_check<'a>(
444 batch: impl Iterator<Item = &'a Self> + Send,
445 ) -> Result<(), SerializationError>
446 where
447 Self: 'a,
448 {
449 T::batch_check(batch.flat_map(|v| v.iter()))
450 }
451}
452
453impl<T: CanonicalDeserialize, const N: usize> CanonicalDeserialize for [T; N] {
454 #[inline]
455 fn deserialize_with_mode<R: Read>(
456 mut reader: R,
457 compress: Compress,
458 validate: Validate,
459 ) -> Result<Self, SerializationError> {
460 let result = core::array::from_fn(|_| {
461 T::deserialize_with_mode(&mut reader, compress, Validate::No).unwrap()
462 });
463 if let Validate::Yes = validate {
464 T::batch_check(result.iter())?
465 }
466 Ok(result)
467 }
468}
469
470impl<T: CanonicalSerialize> CanonicalSerialize for Vec<T> {
471 #[inline]
472 fn serialize_with_mode<W: Write>(
473 &self,
474 mut writer: W,
475 compress: Compress,
476 ) -> Result<(), SerializationError> {
477 self.as_slice().serialize_with_mode(&mut writer, compress)
478 }
479
480 #[inline]
481 fn serialized_size(&self, compress: Compress) -> usize {
482 self.as_slice().serialized_size(compress)
483 }
484}
485
486impl<T: Valid> Valid for Vec<T> {
487 #[inline]
488 fn check(&self) -> Result<(), SerializationError> {
489 T::batch_check(self.iter())
490 }
491
492 #[inline]
493 fn batch_check<'a>(
494 batch: impl Iterator<Item = &'a Self> + Send,
495 ) -> Result<(), SerializationError>
496 where
497 Self: 'a,
498 {
499 T::batch_check(batch.flat_map(|v| v.iter()))
500 }
501}
502
503impl<T: CanonicalDeserialize> CanonicalDeserialize for Vec<T> {
504 #[inline]
505 fn deserialize_with_mode<R: Read>(
506 mut reader: R,
507 compress: Compress,
508 validate: Validate,
509 ) -> Result<Self, SerializationError> {
510 let len = u64::deserialize_with_mode(&mut reader, compress, validate)?;
511 let mut values = Vec::new();
512 for _ in 0..len {
513 values.push(T::deserialize_with_mode(
514 &mut reader,
515 compress,
516 Validate::No,
517 )?);
518 }
519
520 if let Validate::Yes = validate {
521 T::batch_check(values.iter())?
522 }
523 Ok(values)
524 }
525}
526
527impl<T: CanonicalSerialize> CanonicalSerialize for [T] {
528 #[inline]
529 fn serialize_with_mode<W: Write>(
530 &self,
531 mut writer: W,
532 compress: Compress,
533 ) -> Result<(), SerializationError> {
534 let len = self.len() as u64;
535 len.serialize_with_mode(&mut writer, compress)?;
536 for item in self.iter() {
537 item.serialize_with_mode(&mut writer, compress)?;
538 }
539 Ok(())
540 }
541
542 #[inline]
543 fn serialized_size(&self, compress: Compress) -> usize {
544 8 + self
545 .iter()
546 .map(|item| item.serialized_size(compress))
547 .sum::<usize>()
548 }
549}
550
551impl<'a, T: CanonicalSerialize> CanonicalSerialize for &'a [T] {
552 #[inline]
553 fn serialize_with_mode<W: Write>(
554 &self,
555 mut writer: W,
556 compress: Compress,
557 ) -> Result<(), SerializationError> {
558 (*self).serialize_with_mode(&mut writer, compress)
559 }
560
561 #[inline]
562 fn serialized_size(&self, compress: Compress) -> usize {
563 (*self).serialized_size(compress)
564 }
565}
566
567impl CanonicalSerialize for String {
568 #[inline]
569 fn serialize_with_mode<W: Write>(
570 &self,
571 mut writer: W,
572 compress: Compress,
573 ) -> Result<(), SerializationError> {
574 self.as_bytes().serialize_with_mode(&mut writer, compress)
575 }
576
577 #[inline]
578 fn serialized_size(&self, compress: Compress) -> usize {
579 self.as_bytes().serialized_size(compress)
580 }
581}
582
583impl Valid for String {
584 #[inline]
585 fn check(&self) -> Result<(), SerializationError> {
586 Ok(())
587 }
588}
589
590impl CanonicalDeserialize for String {
591 #[inline]
592 fn deserialize_with_mode<R: Read>(
593 reader: R,
594 compress: Compress,
595 validate: Validate,
596 ) -> Result<Self, SerializationError> {
597 let bytes = <Vec<u8>>::deserialize_with_mode(reader, compress, validate)?;
598 String::from_utf8(bytes).map_err(|_| SerializationError::InvalidData)
599 }
600}
601
602macro_rules! impl_tuple {
604 ($( $ty: ident : $no: tt, )*) => {
605 impl<$($ty, )*> Valid for ($($ty,)*) where
606 $($ty: Valid,)*
607 {
608 #[inline]
609 fn check(&self) -> Result<(), SerializationError> {
610 $(self.$no.check()?;)*
611 Ok(())
612 }
613 }
614
615 #[allow(unused)]
616 impl<$($ty, )*> CanonicalSerialize for ($($ty,)*) where
617 $($ty: CanonicalSerialize,)*
618 {
619 #[inline]
620 fn serialize_with_mode<W: Write>(&self, mut writer: W, compress: Compress) -> Result<(), SerializationError> {
621 $(self.$no.serialize_with_mode(&mut writer, compress)?;)*
622 Ok(())
623 }
624
625 #[inline]
626 fn serialized_size(&self, compress: Compress) -> usize {
627 [$(
628 self.$no.serialized_size(compress),
629 )*].iter().sum()
630 }
631 }
632
633 impl<$($ty, )*> CanonicalDeserialize for ($($ty,)*) where
634 $($ty: CanonicalDeserialize,)*
635 {
636 #[inline]
637 #[allow(unused)]
638 fn deserialize_with_mode<R: Read>(mut reader: R, compress: Compress, validate: Validate) -> Result<Self, SerializationError> {
639 Ok(($(
640 $ty::deserialize_with_mode(&mut reader, compress, validate)?,
641 )*))
642 }
643 }
644 }
645}
646
647impl_tuple!();
648impl_tuple!(A:0,);
649impl_tuple!(A:0, B:1,);
650impl_tuple!(A:0, B:1, C:2,);
651impl_tuple!(A:0, B:1, C:2, D:3,);
652
653impl<K, V> CanonicalSerialize for BTreeMap<K, V>
654where
655 K: CanonicalSerialize,
656 V: CanonicalSerialize,
657{
658 fn serialize_with_mode<W: Write>(
660 &self,
661 mut writer: W,
662 compress: Compress,
663 ) -> Result<(), SerializationError> {
664 let len = self.len() as u64;
665 len.serialize_with_mode(&mut writer, compress)?;
666 for (k, v) in self.iter() {
667 k.serialize_with_mode(&mut writer, compress)?;
668 v.serialize_with_mode(&mut writer, compress)?;
669 }
670 Ok(())
671 }
672
673 fn serialized_size(&self, compress: Compress) -> usize {
674 8 + self
675 .iter()
676 .map(|(k, v)| k.serialized_size(compress) + v.serialized_size(compress))
677 .sum::<usize>()
678 }
679}
680
681impl<K: Valid, V: Valid> Valid for BTreeMap<K, V> {
682 #[inline]
683 fn check(&self) -> Result<(), SerializationError> {
684 K::batch_check(self.keys())?;
685 V::batch_check(self.values())
686 }
687
688 #[inline]
689 fn batch_check<'a>(batch: impl Iterator<Item = &'a Self>) -> Result<(), SerializationError>
690 where
691 Self: 'a,
692 {
693 let (keys, values): (Vec<_>, Vec<_>) = batch.map(|b| (b.keys(), b.values())).unzip();
694 K::batch_check(keys.into_iter().flatten())?;
695 V::batch_check(values.into_iter().flatten())
696 }
697}
698
699impl<K, V> CanonicalDeserialize for BTreeMap<K, V>
700where
701 K: Ord + CanonicalDeserialize,
702 V: CanonicalDeserialize,
703{
704 fn deserialize_with_mode<R: Read>(
706 mut reader: R,
707 compress: Compress,
708 validate: Validate,
709 ) -> Result<Self, SerializationError> {
710 let len = u64::deserialize_with_mode(&mut reader, compress, validate)?;
711 (0..len)
712 .map(|_| {
713 Ok((
714 K::deserialize_with_mode(&mut reader, compress, validate)?,
715 V::deserialize_with_mode(&mut reader, compress, validate)?,
716 ))
717 })
718 .collect()
719 }
720}
721
722impl<V: CanonicalSerialize> CanonicalSerialize for BTreeSet<V> {
723 fn serialize_with_mode<W: Write>(
725 &self,
726 mut writer: W,
727 compress: Compress,
728 ) -> Result<(), SerializationError> {
729 let len = self.len() as u64;
730 len.serialize_with_mode(&mut writer, compress)?;
731 for v in self {
732 v.serialize_with_mode(&mut writer, compress)?;
733 }
734 Ok(())
735 }
736
737 fn serialized_size(&self, compress: Compress) -> usize {
738 8 + self
739 .iter()
740 .map(|v| v.serialized_size(compress))
741 .sum::<usize>()
742 }
743}
744
745impl<V: Valid> Valid for BTreeSet<V> {
746 #[inline]
747 fn check(&self) -> Result<(), SerializationError> {
748 V::batch_check(self.iter())
749 }
750
751 #[inline]
752 fn batch_check<'a>(
753 batch: impl Iterator<Item = &'a Self> + Send,
754 ) -> Result<(), SerializationError>
755 where
756 Self: 'a,
757 {
758 V::batch_check(batch.flat_map(|s| s.iter()))
759 }
760}
761
762impl<V> CanonicalDeserialize for BTreeSet<V>
763where
764 V: Ord + CanonicalDeserialize,
765{
766 fn deserialize_with_mode<R: Read>(
768 mut reader: R,
769 compress: Compress,
770 validate: Validate,
771 ) -> Result<Self, SerializationError> {
772 let len = u64::deserialize_with_mode(&mut reader, compress, validate)?;
773 (0..len)
774 .map(|_| V::deserialize_with_mode(&mut reader, compress, validate))
775 .collect()
776 }
777}