ethnum/
serde.rs

1//! Serde serialization implementation for 256-bit integer types.
2//!
3//! This implementation is very JSON-centric in that it serializes the integer
4//! types as `QUANTITIES` as specified in the Ethereum RPC. That is, integers
5//! are encoded as `"0x"` prefixed strings without extrenuous leading `0`s. For
6//! negative signed integers, the string is prefixed with a `"-"` sign.
7//!
8//! Note that this module contains alternative serialization schemes that can
9//! be used with `#[serde(with = "...")]`.
10//!
11//! # Examples
12//!
13//! Basic usage:
14//!
15//! ```text
16//! #[derive(Deserialize, Serialize)]
17//! struct Example {
18//!     a: U256, // "0x2a"
19//!     #[serde(with = "ethnum::serde::decimal")]
20//!     b: I256, // "-42"
21//!     #[serde(with = "ethnum::serde::prefixed")]
22//!     c: U256, // "0x2a" or "42"
23//!     #[serde(with = "ethnum::serde::permissive")]
24//!     d: I256, // "-0x2a" or "-42" or -42
25//!     #[serde(with = "ethnum::serde::bytes::be")]
26//!     e: U256, // [0x2a, 0x00, ..., 0x00]
27//!     #[serde(with = "ethnum::serde::bytes::le")]
28//!     f: I256, // [0xd6, 0xff, ..., 0xff]
29//!     #[serde(with = "ethnum::serde::compressed_bytes::be")]
30//!     g: U256, // [0x2a]
31//!     #[serde(with = "ethnum::serde::compressed_bytes::le")]
32//!     h: I256, // [0xd6]
33//! }
34//! ```
35
36use crate::{int::I256, uint::U256};
37use core::{
38    fmt::{self, Display, Formatter, Write},
39    mem::MaybeUninit,
40    ptr, slice, str,
41};
42use serde::{
43    de::{self, Visitor},
44    Deserialize, Deserializer, Serialize, Serializer,
45};
46
47impl Serialize for I256 {
48    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
49    where
50        S: Serializer,
51    {
52        let mut f = FormatBuffer::hex();
53        write!(f, "{self:-#x}").expect("unexpected formatting failure");
54        serializer.serialize_str(f.as_str())
55    }
56}
57
58impl Serialize for U256 {
59    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
60    where
61        S: Serializer,
62    {
63        let mut f = FormatBuffer::hex();
64        write!(f, "{self:#x}").expect("unexpected formatting failure");
65        serializer.serialize_str(f.as_str())
66    }
67}
68
69impl<'de> Deserialize<'de> for I256 {
70    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71    where
72        D: Deserializer<'de>,
73    {
74        deserializer.deserialize_str(FormatVisitor(Self::from_str_hex))
75    }
76}
77
78impl<'de> Deserialize<'de> for U256 {
79    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
80    where
81        D: Deserializer<'de>,
82    {
83        deserializer.deserialize_str(FormatVisitor(Self::from_str_hex))
84    }
85}
86
87/// Module for use with `#[serde(with = "ethnum::serde::decimal")]` to specify
88/// decimal string serialization for 256-bit integer types.
89pub mod decimal {
90    use super::*;
91    use core::num::ParseIntError;
92
93    #[doc(hidden)]
94    pub trait Decimal: Sized {
95        fn from_str_decimal(src: &str) -> Result<Self, ParseIntError>;
96        fn write_decimal(&self, f: &mut impl Write);
97    }
98
99    impl Decimal for I256 {
100        fn from_str_decimal(src: &str) -> Result<Self, ParseIntError> {
101            Self::from_str_radix(src, 10)
102        }
103        fn write_decimal(&self, f: &mut impl Write) {
104            write!(f, "{self}").expect("unexpected formatting error")
105        }
106    }
107
108    impl Decimal for U256 {
109        fn from_str_decimal(src: &str) -> Result<Self, ParseIntError> {
110            Self::from_str_radix(src, 10)
111        }
112        fn write_decimal(&self, f: &mut impl Write) {
113            write!(f, "{self}").expect("unexpected formatting error")
114        }
115    }
116
117    #[doc(hidden)]
118    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
119    where
120        T: Decimal,
121        S: Serializer,
122    {
123        let mut f = FormatBuffer::decimal();
124        value.write_decimal(&mut f);
125        serializer.serialize_str(f.as_str())
126    }
127
128    #[doc(hidden)]
129    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
130    where
131        T: Decimal,
132        D: Deserializer<'de>,
133    {
134        deserializer.deserialize_str(FormatVisitor(T::from_str_decimal))
135    }
136}
137
138/// Module for use with `#[serde(with = "ethnum::serde::prefixed")]` to specify
139/// prefixed string serialization for 256-bit integer types.
140///
141/// This allows serialization to look for an optional `0x` prefix to determine
142/// if it is a hexadecimal string or decimal string.
143pub mod prefixed {
144    use super::*;
145    use core::num::ParseIntError;
146
147    #[doc(hidden)]
148    pub trait Prefixed: Serialize + Sized {
149        fn from_str_prefixed(src: &str) -> Result<Self, ParseIntError>;
150    }
151
152    impl Prefixed for I256 {
153        fn from_str_prefixed(src: &str) -> Result<Self, ParseIntError> {
154            Self::from_str_prefixed(src)
155        }
156    }
157
158    impl Prefixed for U256 {
159        fn from_str_prefixed(src: &str) -> Result<Self, ParseIntError> {
160            Self::from_str_prefixed(src)
161        }
162    }
163
164    #[doc(hidden)]
165    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
166    where
167        T: Prefixed,
168        S: Serializer,
169    {
170        value.serialize(serializer)
171    }
172
173    #[doc(hidden)]
174    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
175    where
176        T: Prefixed,
177        D: Deserializer<'de>,
178    {
179        deserializer.deserialize_str(FormatVisitor(T::from_str_prefixed))
180    }
181}
182
183/// Module for use with `#[serde(with = "ethnum::serde::permissive")]` to
184/// specify extremely permissive serialization for 256-bit integer types.
185///
186/// This allows serialization to also accept standard numerical types as values
187/// in addition to prefixed strings.
188pub mod permissive {
189    use super::{prefixed::Prefixed, FormatVisitor};
190    use crate::{AsI256 as _, I256, U256};
191    use core::fmt::{self, Formatter};
192    use core::marker::PhantomData;
193    use serde::{
194        de::{self, Deserializer, Visitor},
195        Serializer,
196    };
197
198    #[doc(hidden)]
199    pub trait Permissive: Prefixed {
200        fn cast(value: I256) -> Self;
201    }
202
203    impl Permissive for I256 {
204        fn cast(value: I256) -> Self {
205            value
206        }
207    }
208
209    impl Permissive for U256 {
210        fn cast(value: I256) -> Self {
211            value.as_u256()
212        }
213    }
214
215    #[doc(hidden)]
216    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
217    where
218        T: Permissive,
219        S: Serializer,
220    {
221        value.serialize(serializer)
222    }
223
224    struct PermissiveVisitor<T>(PhantomData<T>);
225
226    impl<T> Visitor<'_> for PermissiveVisitor<T>
227    where
228        T: Permissive,
229    {
230        type Value = T;
231
232        fn expecting(&self, f: &mut Formatter) -> fmt::Result {
233            f.write_str("number, decimal string or '0x-' prefixed hexadecimal string")
234        }
235
236        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
237        where
238            E: de::Error,
239        {
240            Ok(T::cast(v.as_i256()))
241        }
242
243        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
244        where
245            E: de::Error,
246        {
247            Ok(T::cast(v.as_i256()))
248        }
249
250        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
251        where
252            E: de::Error,
253        {
254            Ok(T::cast(v.as_i256()))
255        }
256
257        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
258        where
259            E: de::Error,
260        {
261            Ok(T::cast(v.as_i256()))
262        }
263
264        fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
265        where
266            E: de::Error,
267        {
268            const N: f32 = (1_u64 << 24) as _;
269            if !(-N..N).contains(&v) {
270                return Err(de::Error::custom(
271                    "invalid conversion from single precision floating point \
272                     number outside of valid integer range (-2^24, 2^24)",
273                ));
274            }
275
276            self.visit_f64(v as _)
277        }
278
279        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
280        where
281            E: de::Error,
282        {
283            const N: f64 = (1_u64 << 53) as _;
284            if !(-N..N).contains(&v) {
285                return Err(de::Error::custom(
286                    "invalid conversion from double precision floating point \
287                     number outside of valid integer range (-2^53, 2^53)",
288                ));
289            }
290
291            // SOUNDNESS: `#[no_std]` does not have `f64::fract`, so work around
292            // it by casting to and from an integer type. This is sound because
293            // we already verified that the `f64` is within a "safe" range.
294            let i = v as i64;
295            if i as f64 != v {
296                return Err(de::Error::custom(
297                    "invalid conversion from floating point number \
298                     with fractional part to 256-bit integer",
299                ));
300            }
301
302            Ok(T::cast(i.as_i256()))
303        }
304
305        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
306        where
307            E: de::Error,
308        {
309            FormatVisitor(T::from_str_prefixed).visit_str(v)
310        }
311    }
312
313    #[doc(hidden)]
314    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
315    where
316        T: Permissive,
317        D: Deserializer<'de>,
318    {
319        deserializer.deserialize_any(PermissiveVisitor(PhantomData))
320    }
321}
322
323/// Serde byte serialization for 256-bit integer types.
324pub mod bytes {
325    macro_rules! endianness {
326        ($name:literal; $to:ident, $from:ident) => {
327            use crate::{I256, U256};
328            use core::{
329                fmt::{self, Formatter},
330                marker::PhantomData,
331                mem::{self, MaybeUninit},
332            };
333            use serde::{
334                de::{self, Deserializer, Visitor},
335                Serializer,
336            };
337
338            #[doc(hidden)]
339            pub trait Bytes: Sized + Copy {
340                fn to_bytes(self) -> [u8; 32];
341                fn from_bytes(bytes: [u8; 32]) -> Self;
342            }
343
344            impl Bytes for I256 {
345                fn to_bytes(self) -> [u8; 32] {
346                    self.$to()
347                }
348
349                fn from_bytes(bytes: [u8; 32]) -> Self {
350                    I256::$from(bytes)
351                }
352            }
353
354            impl Bytes for U256 {
355                fn to_bytes(self) -> [u8; 32] {
356                    self.$to()
357                }
358
359                fn from_bytes(bytes: [u8; 32]) -> Self {
360                    U256::$from(bytes)
361                }
362            }
363
364            #[doc(hidden)]
365            pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
366            where
367                T: Bytes,
368                S: Serializer,
369            {
370                let bytes = value.to_bytes();
371                serializer.serialize_bytes(&bytes)
372            }
373
374            struct BytesVisitor<T>(PhantomData<T>);
375
376            impl<'de, T> Visitor<'de> for BytesVisitor<T>
377            where
378                T: Bytes,
379            {
380                type Value = T;
381
382                fn expecting(&self, f: &mut Formatter) -> fmt::Result {
383                    f.write_str(concat!("32 bytes in ", $name, " endian"))
384                }
385
386                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
387                where
388                    E: de::Error,
389                {
390                    let bytes = v
391                        .try_into()
392                        .map_err(|_| E::invalid_length(v.len(), &self))?;
393
394                    Ok(T::from_bytes(bytes))
395                }
396
397                fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
398                where
399                    S: de::SeqAccess<'de>,
400                {
401                    match seq.size_hint() {
402                        Some(len) if len != 32 => {
403                            return Err(de::Error::invalid_length(len, &self))
404                        }
405                        _ => {}
406                    }
407
408                    let mut bytes = [MaybeUninit::<u8>::uninit(); 32];
409                    for i in 0..32 {
410                        bytes[i].write(
411                            seq.next_element()?
412                                .ok_or(de::Error::invalid_length(i, &self))?,
413                        );
414                    }
415                    if seq.next_element::<u8>()?.is_some() {
416                        return Err(de::Error::invalid_length(33, &self));
417                    }
418
419                    // SAFETY: all bytes have been initialized in for loop.
420                    let bytes = unsafe { mem::transmute::<[MaybeUninit<u8>; 32], [u8; 32]>(bytes) };
421
422                    Ok(T::from_bytes(bytes))
423                }
424            }
425
426            #[doc(hidden)]
427            pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
428            where
429                T: Bytes,
430                D: Deserializer<'de>,
431            {
432                deserializer.deserialize_bytes(BytesVisitor(PhantomData))
433            }
434        };
435    }
436
437    /// Module for use with `#[serde(with = "ethnum::serde::bytes::le")]` to
438    /// specify little endian byte serialization for 256-bit integer types.
439    pub mod le {
440        endianness!("little"; to_le_bytes, from_le_bytes);
441    }
442
443    /// Module for use with `#[serde(with = "ethnum::serde::bytes::be")]` to
444    /// specify big endian byte serialization for 256-bit integer types.
445    pub mod be {
446        endianness!("big"; to_be_bytes, from_be_bytes);
447    }
448
449    /// Module for use with `#[serde(with = "ethnum::serde::bytes::ne")]` to
450    /// specify native endian byte serialization for 256-bit integer types.
451    pub mod ne {
452        #[cfg(target_endian = "little")]
453        #[doc(hidden)]
454        pub use super::le::{deserialize, serialize};
455
456        #[cfg(target_endian = "big")]
457        #[doc(hidden)]
458        pub use super::be::{deserialize, serialize};
459    }
460}
461
462/// Serde compressed byte serialization for 256-bit integer types.
463pub mod compressed_bytes {
464    use crate::{I256, U256};
465
466    #[doc(hidden)]
467    pub trait CompressedBytes {
468        fn leading_bits(&self) -> u32;
469        fn extend(msb: u8) -> u8;
470    }
471
472    impl CompressedBytes for I256 {
473        fn leading_bits(&self) -> u32 {
474            match self.is_negative() {
475                true => self.leading_ones() - 1,
476                false => self.leading_zeros(),
477            }
478        }
479
480        fn extend(msb: u8) -> u8 {
481            ((msb as i8) >> 7) as _
482        }
483    }
484
485    impl CompressedBytes for U256 {
486        fn leading_bits(&self) -> u32 {
487            self.leading_zeros()
488        }
489
490        fn extend(_: u8) -> u8 {
491            0
492        }
493    }
494
495    macro_rules! endianness {
496        ($name:literal; $parent:ident, |$tb:ident| $to:block, |$fb:ident| $from:block) => {
497            use super::CompressedBytes;
498            use crate::serde::bytes::$parent::Bytes;
499            use core::{
500                fmt::{self, Formatter},
501                marker::PhantomData,
502                mem::MaybeUninit,
503            };
504            use serde::{
505                de::{self, Deserializer, Visitor},
506                Serializer,
507            };
508
509            #[doc(hidden)]
510            pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
511            where
512                T: Bytes + CompressedBytes,
513                S: Serializer,
514            {
515                let bytes = value.to_bytes();
516                let $tb = (value.leading_bits() as usize) / 8;
517                let index = { $to };
518                serializer.serialize_bytes(&bytes[index])
519            }
520
521            struct CompressedBytesVisitor<T>(PhantomData<T>);
522
523            impl<'de, T> Visitor<'de> for CompressedBytesVisitor<T>
524            where
525                T: Bytes + CompressedBytes,
526            {
527                type Value = T;
528
529                fn expecting(&self, f: &mut Formatter) -> fmt::Result {
530                    f.write_str(concat!("bytes in ", $name, " endian"))
531                }
532
533                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
534                where
535                    E: de::Error,
536                {
537                    if v.len() > 32 {
538                        return Err(E::invalid_length(v.len(), &self));
539                    }
540
541                    let extend = T::extend(v.last().copied().unwrap_or_default());
542                    let mut bytes = [extend; 32];
543                    let $fb = v.len();
544                    let index = { $from };
545                    bytes[index].copy_from_slice(v);
546
547                    Ok(T::from_bytes(bytes))
548                }
549
550                fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
551                where
552                    S: de::SeqAccess<'de>,
553                {
554                    match seq.size_hint() {
555                        Some(len) if len > 32 => return Err(de::Error::invalid_length(len, &self)),
556                        _ => {}
557                    }
558
559                    let mut bytes = [MaybeUninit::<u8>::uninit(); 32];
560                    let mut i = 0;
561                    while i < 32 {
562                        let b = match seq.next_element()? {
563                            Some(b) => b,
564                            None => break,
565                        };
566                        bytes[i].write(b);
567                        i += 1;
568                    }
569                    if i == 32 && seq.next_element::<u8>()?.is_some() {
570                        return Err(de::Error::invalid_length(33, &self));
571                    }
572
573                    // SAFETY: bytes up to `i` have been initialized in while
574                    // loop.
575                    let bytes = unsafe { &*(&bytes[..i] as *const _ as *const _) };
576
577                    self.visit_bytes(bytes)
578                }
579            }
580
581            #[doc(hidden)]
582            pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
583            where
584                T: Bytes + CompressedBytes,
585                D: Deserializer<'de>,
586            {
587                deserializer.deserialize_bytes(CompressedBytesVisitor(PhantomData))
588            }
589        };
590    }
591
592    /// Module for `#[serde(with = "ethnum::serde::compressed_bytes::le")]`
593    /// to specify compressed little endian byte serialization for 256-bit
594    /// integer types. This will serialize integer types with as few bytes as
595    /// possible.
596    pub mod le {
597        endianness!("little"; le, |l| { ..32 - l }, |l| { ..l });
598    }
599
600    /// Module for `#[serde(with = "ethnum::serde::compressed_bytes::be")]`
601    /// to specify compressed big endian byte serialization for 256-bit
602    /// integer types. This will serialize integer types with as few bytes as
603    /// possible.
604    pub mod be {
605        endianness!("big"; be, |l| { l.. }, |l| { 32 - l.. });
606    }
607
608    /// Module for `#[serde(with = "ethnum::serde::compressed_bytes::ne")]`
609    /// to specify compressed native endian byte serialization for 256-bit
610    /// integer types. This will serialize integer types with as few bytes as
611    /// possible.
612    pub mod ne {
613        #[cfg(target_endian = "little")]
614        #[doc(hidden)]
615        pub use super::le::{deserialize, serialize};
616
617        #[cfg(target_endian = "big")]
618        #[doc(hidden)]
619        pub use super::be::{deserialize, serialize};
620    }
621}
622
623/// Internal visitor struct implementation to facilitate implementing different
624/// serialization formats.
625struct FormatVisitor<F>(F);
626
627impl<T, E, F> Visitor<'_> for FormatVisitor<F>
628where
629    E: Display,
630    F: FnOnce(&str) -> Result<T, E>,
631{
632    type Value = T;
633
634    fn expecting(&self, f: &mut Formatter) -> fmt::Result {
635        f.write_str("a formatted 256-bit integer")
636    }
637
638    fn visit_str<E_>(self, v: &str) -> Result<Self::Value, E_>
639    where
640        E_: de::Error,
641    {
642        self.0(v).map_err(de::Error::custom)
643    }
644
645    fn visit_bytes<E_>(self, v: &[u8]) -> Result<Self::Value, E_>
646    where
647        E_: de::Error,
648    {
649        let string = str::from_utf8(v)
650            .map_err(|_| de::Error::invalid_value(de::Unexpected::Bytes(v), &self))?;
651        self.visit_str(string)
652    }
653}
654
655/// A stack-allocated buffer that can be used for writing formatted strings.
656///
657/// This allows us to leverage existing `fmt` implementations on integer types
658/// without requiring heap allocations (i.e. writing to a `String` buffer).
659struct FormatBuffer<const N: usize> {
660    offset: usize,
661    buffer: [MaybeUninit<u8>; N],
662}
663
664impl<const N: usize> FormatBuffer<N> {
665    /// Creates a new formatting buffer.
666    fn new() -> Self {
667        Self {
668            offset: 0,
669            buffer: [MaybeUninit::uninit(); N],
670        }
671    }
672
673    /// Returns a `str` to the currently written data.
674    fn as_str(&self) -> &str {
675        // SAFETY: We only ever write valid UTF-8 strings to the buffer, so the
676        // resulting string will always be valid.
677        unsafe {
678            let buffer = slice::from_raw_parts(self.buffer[0].as_ptr(), self.offset);
679            str::from_utf8_unchecked(buffer)
680        }
681    }
682}
683
684impl FormatBuffer<78> {
685    /// Allocates a formatting buffer large enough to hold any possible decimal
686    /// encoded 256-bit value.
687    fn decimal() -> Self {
688        Self::new()
689    }
690}
691
692impl FormatBuffer<67> {
693    /// Allocates a formatting buffer large enough to hold any possible
694    /// hexadecimal encoded 256-bit value.
695    fn hex() -> Self {
696        Self::new()
697    }
698}
699
700impl<const N: usize> Write for FormatBuffer<N> {
701    fn write_str(&mut self, s: &str) -> fmt::Result {
702        let end = self.offset.checked_add(s.len()).ok_or(fmt::Error)?;
703
704        // Make sure there is enough space in the buffer.
705        if end > N {
706            return Err(fmt::Error);
707        }
708
709        // SAFETY: We checked that there is enough space in the buffer to fit
710        // the string `s` starting from `offset`, and the pointers cannot be
711        // overlapping because of Rust ownership semantics (i.e. `s` cannot
712        // overlap with `buffer` because we have a mutable reference to `self`
713        // and by extension `buffer`).
714        unsafe {
715            let buffer = self.buffer[0].as_mut_ptr().add(self.offset);
716            ptr::copy_nonoverlapping(s.as_ptr(), buffer, s.len());
717        }
718        self.offset = end;
719
720        Ok(())
721    }
722}
723
724#[cfg(test)]
725mod tests {
726    use super::*;
727    use alloc::{
728        boxed::Box,
729        fmt::{Display, LowerHex},
730        format,
731        string::String,
732        vec,
733        vec::Vec,
734    };
735    use serde::{
736        de::{value, IntoDeserializer},
737        ser::Impossible,
738    };
739
740    #[test]
741    fn serialize_integers() {
742        macro_rules! ser {
743            ($method:expr, $value:expr) => {{
744                let value = $value;
745                ($method)(&value, StringSerializer).unwrap()
746            }};
747        }
748
749        macro_rules! bin_ser {
750            ($method:expr, $value:expr) => {{
751                let value = $value;
752                ($method)(&value, BytesSerializer).unwrap()
753            }};
754        }
755
756        assert_eq!(
757            ser!(I256::serialize, I256::MIN),
758            "-0x8000000000000000000000000000000000000000000000000000000000000000",
759        );
760        assert_eq!(ser!(I256::serialize, I256::new(-1)), "-0x1");
761        assert_eq!(ser!(I256::serialize, I256::new(0)), "0x0");
762        assert_eq!(ser!(I256::serialize, I256::new(42)), "0x2a");
763
764        assert_eq!(ser!(U256::serialize, U256::new(0)), "0x0");
765        assert_eq!(ser!(U256::serialize, U256::new(4919)), "0x1337");
766        assert_eq!(
767            ser!(U256::serialize, U256::MAX),
768            "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
769        );
770
771        assert_eq!(
772            ser!(decimal::serialize, I256::MIN),
773            "-57896044618658097711785492504343953926634992332820282019728792003956564819968",
774        );
775        assert_eq!(ser!(decimal::serialize, I256::new(-1)), "-1");
776        assert_eq!(ser!(decimal::serialize, I256::new(0)), "0");
777        assert_eq!(ser!(decimal::serialize, I256::new(42)), "42");
778
779        assert_eq!(ser!(decimal::serialize, U256::new(0)), "0");
780        assert_eq!(ser!(decimal::serialize, U256::new(4919)), "4919");
781        assert_eq!(
782            ser!(decimal::serialize, U256::MAX),
783            "115792089237316195423570985008687907853269984665640564039457584007913129639935",
784        );
785
786        assert_eq!(ser!(prefixed::serialize, I256::new(42)), "0x2a");
787        assert_eq!(ser!(permissive::serialize, I256::new(42)), "0x2a");
788
789        assert_eq!(bin_ser!(bytes::le::serialize, U256::ZERO), vec![0x00; 32]);
790        assert_eq!(bin_ser!(bytes::le::serialize, U256::MAX), vec![0xff; 32]);
791        assert_eq!(bin_ser!(bytes::le::serialize, U256::new(0x4215)), {
792            let mut v = vec![0x15, 0x42];
793            v.resize(32, 0x00);
794            v
795        });
796
797        assert_eq!(
798            bin_ser!(bytes::le::serialize, I256::new(-1)),
799            vec![0xff; 32]
800        );
801        assert_eq!(bin_ser!(bytes::le::serialize, I256::new(-424242)), {
802            let mut v = vec![0xce, 0x86, 0xf9];
803            v.resize(32, 0xff);
804            v
805        });
806
807        assert_eq!(bin_ser!(bytes::be::serialize, U256::ZERO), vec![0x00; 32]);
808        assert_eq!(bin_ser!(bytes::be::serialize, U256::MAX), vec![0xff; 32]);
809        assert_eq!(bin_ser!(bytes::be::serialize, U256::new(0x4215)), {
810            let mut v = vec![0x00; 32];
811            v[30..].copy_from_slice(&[0x42, 0x15]);
812            v
813        });
814
815        assert_eq!(
816            bin_ser!(bytes::be::serialize, I256::new(-1)),
817            vec![0xff; 32]
818        );
819        assert_eq!(bin_ser!(bytes::be::serialize, I256::new(-424242)), {
820            let mut v = vec![0xff; 32];
821            v[29..].copy_from_slice(&[0xf9, 0x86, 0xce]);
822            v
823        });
824
825        assert_eq!(
826            bin_ser!(compressed_bytes::le::serialize, U256::ZERO),
827            vec![]
828        );
829        assert_eq!(
830            bin_ser!(compressed_bytes::le::serialize, U256::MAX),
831            vec![0xff; 32],
832        );
833        assert_eq!(
834            bin_ser!(compressed_bytes::le::serialize, U256::new(0x4215)),
835            vec![0x15, 0x42],
836        );
837
838        assert_eq!(bin_ser!(compressed_bytes::le::serialize, I256::MIN), {
839            let mut v = vec![0; 32];
840            v[31] = 0x80;
841            v
842        });
843        assert_eq!(
844            bin_ser!(compressed_bytes::le::serialize, I256::ZERO),
845            vec![]
846        );
847        assert_eq!(
848            bin_ser!(compressed_bytes::le::serialize, I256::new(-1)),
849            vec![0xff],
850        );
851        assert_eq!(
852            bin_ser!(compressed_bytes::le::serialize, I256::new(-0x8000)),
853            vec![0x00, 0x80],
854        );
855        assert_eq!(
856            bin_ser!(compressed_bytes::le::serialize, I256::new(-424242)),
857            vec![0xce, 0x86, 0xf9],
858        );
859
860        assert_eq!(
861            bin_ser!(compressed_bytes::be::serialize, U256::ZERO),
862            vec![]
863        );
864        assert_eq!(
865            bin_ser!(compressed_bytes::be::serialize, U256::MAX),
866            vec![0xff; 32],
867        );
868        assert_eq!(
869            bin_ser!(compressed_bytes::be::serialize, U256::new(0x4215)),
870            vec![0x42, 0x15],
871        );
872
873        assert_eq!(bin_ser!(compressed_bytes::be::serialize, I256::MIN), {
874            let mut v = vec![0; 32];
875            v[0] = 0x80;
876            v
877        });
878        assert_eq!(
879            bin_ser!(compressed_bytes::be::serialize, I256::ZERO),
880            vec![]
881        );
882        assert_eq!(
883            bin_ser!(compressed_bytes::be::serialize, I256::new(-1)),
884            vec![0xff],
885        );
886        assert_eq!(
887            bin_ser!(compressed_bytes::be::serialize, I256::new(-0x8000)),
888            vec![0x80, 0x00],
889        );
890        assert_eq!(
891            bin_ser!(compressed_bytes::be::serialize, I256::new(-424242)),
892            vec![0xf9, 0x86, 0xce],
893        );
894    }
895
896    #[test]
897    fn deserialize_integers() {
898        macro_rules! de {
899            ($method:expr, $src:expr) => {{
900                let deserializer = IntoDeserializer::<value::Error>::into_deserializer($src);
901                ($method)(deserializer).unwrap()
902            }};
903            (err; $method:expr, $src:expr) => {{
904                let deserializer = IntoDeserializer::<value::Error>::into_deserializer($src);
905                ($method)(deserializer).is_err()
906            }};
907        }
908
909        macro_rules! assert_de_bytes {
910            ($method:expr, $src:expr; eq: $exp:expr) => {{
911                let src = $src;
912                let exp = $exp;
913
914                assert_eq!(de!($method, src.as_slice()), exp);
915
916                let seq =
917                    value::SeqDeserializer::<_, value::Error>::new(src.into_iter());
918                assert_eq!(($method)(seq).unwrap(), exp);
919            }};
920            ($method:expr, $src:expr; err) => {{
921                let src = $src;
922                assert!(de!(err; $method, src.as_slice()));
923                let seq =
924                    value::SeqDeserializer::<_, value::Error>::new(src.into_iter());
925                assert!(($method)(seq).is_err());
926            }};
927        }
928
929        assert_eq!(
930            de!(
931                I256::deserialize,
932                "-0x8000000000000000000000000000000000000000000000000000000000000000"
933            ),
934            I256::MIN
935        );
936        assert_eq!(de!(I256::deserialize, "-0x1337"), I256::new(-4919));
937        assert_eq!(de!(I256::deserialize, "0x0"), I256::new(0));
938        assert_eq!(de!(I256::deserialize, "0x2a"), I256::new(42));
939        assert_eq!(de!(I256::deserialize, "0x2A"), I256::new(42));
940
941        assert_eq!(de!(U256::deserialize, "0x0"), U256::new(0));
942        assert_eq!(de!(U256::deserialize, "0x2a"), U256::new(42));
943        assert_eq!(de!(U256::deserialize, "0x2A"), U256::new(42));
944        assert_eq!(
945            de!(
946                U256::deserialize,
947                "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
948            ),
949            U256::MAX
950        );
951
952        assert_eq!(
953            de!(
954                decimal::deserialize::<I256, _>,
955                "-57896044618658097711785492504343953926634992332820282019728792003956564819968"
956            ),
957            I256::MIN
958        );
959        assert_eq!(de!(decimal::deserialize::<I256, _>, "-1"), I256::new(-1));
960        assert_eq!(de!(decimal::deserialize::<I256, _>, "0"), I256::new(0));
961        assert_eq!(de!(decimal::deserialize::<I256, _>, "42"), I256::new(42));
962
963        assert_eq!(de!(decimal::deserialize::<U256, _>, "0"), U256::new(0));
964        assert_eq!(de!(decimal::deserialize::<U256, _>, "42"), U256::new(42));
965        assert_eq!(
966            de!(
967                decimal::deserialize::<U256, _>,
968                "115792089237316195423570985008687907853269984665640564039457584007913129639935"
969            ),
970            U256::MAX
971        );
972
973        assert_eq!(de!(prefixed::deserialize::<I256, _>, "-1"), I256::new(-1));
974        assert_eq!(de!(prefixed::deserialize::<I256, _>, "-0x1"), I256::new(-1));
975        assert_eq!(de!(prefixed::deserialize::<I256, _>, "42"), I256::new(42));
976        assert_eq!(de!(prefixed::deserialize::<I256, _>, "0x2a"), I256::new(42));
977        assert_eq!(de!(prefixed::deserialize::<I256, _>, "0x2A"), I256::new(42));
978
979        assert_eq!(de!(prefixed::deserialize::<U256, _>, "42"), U256::new(42));
980        assert_eq!(de!(prefixed::deserialize::<U256, _>, "0x2a"), U256::new(42));
981        assert_eq!(de!(prefixed::deserialize::<U256, _>, "0x2A"), U256::new(42));
982
983        assert_eq!(
984            de!(permissive::deserialize::<I256, _>, -42_i64),
985            I256::new(-42)
986        );
987        assert_eq!(
988            de!(permissive::deserialize::<I256, _>, 42_u64),
989            I256::new(42)
990        );
991        assert_eq!(
992            de!(permissive::deserialize::<I256, _>, -1337_i128),
993            I256::new(-1337)
994        );
995        assert_eq!(
996            de!(permissive::deserialize::<I256, _>, 1337_u128),
997            I256::new(1337)
998        );
999        assert_eq!(
1000            de!(permissive::deserialize::<I256, _>, 100.0_f32),
1001            I256::new(100)
1002        );
1003        assert_eq!(
1004            de!(permissive::deserialize::<I256, _>, -100.0_f64),
1005            I256::new(-100)
1006        );
1007        assert_eq!(de!(permissive::deserialize::<I256, _>, "-1"), I256::new(-1));
1008        assert_eq!(
1009            de!(permissive::deserialize::<I256, _>, "1000"),
1010            I256::new(1000)
1011        );
1012        assert_eq!(
1013            de!(permissive::deserialize::<I256, _>, "0x42"),
1014            I256::new(0x42)
1015        );
1016        assert_eq!(
1017            de!(permissive::deserialize::<I256, _>, "-0x2a"),
1018            I256::new(-42)
1019        );
1020        assert_eq!(
1021            de!(
1022                permissive::deserialize::<I256, _>,
1023                "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1024            ),
1025            I256::MAX
1026        );
1027        assert_eq!(
1028            de!(
1029                permissive::deserialize::<I256, _>,
1030                "-0x8000000000000000000000000000000000000000000000000000000000000000"
1031            ),
1032            I256::MIN
1033        );
1034
1035        assert_eq!(
1036            de!(permissive::deserialize::<U256, _>, 42_u64),
1037            U256::new(42)
1038        );
1039        assert_eq!(
1040            de!(permissive::deserialize::<U256, _>, 1337_u128),
1041            U256::new(1337)
1042        );
1043        assert_eq!(
1044            de!(permissive::deserialize::<U256, _>, 100.0_f32),
1045            U256::new(100)
1046        );
1047        assert_eq!(
1048            de!(permissive::deserialize::<U256, _>, 100.0_f64),
1049            U256::new(100)
1050        );
1051        assert_eq!(
1052            de!(permissive::deserialize::<U256, _>, "1000"),
1053            U256::new(1000)
1054        );
1055        assert_eq!(
1056            de!(permissive::deserialize::<U256, _>, "0x42"),
1057            U256::new(0x42)
1058        );
1059        assert_eq!(
1060            de!(
1061                permissive::deserialize::<U256, _>,
1062                "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
1063            ),
1064            U256::MAX
1065        );
1066
1067        assert!(de!(err; permissive::deserialize::<I256, _>, 4.2_f32));
1068        assert!(de!(err; permissive::deserialize::<I256, _>, 16777216.0_f32));
1069        assert!(de!(err; permissive::deserialize::<I256, _>, -13.37_f64));
1070        assert!(de!(err; permissive::deserialize::<I256, _>, 9007199254740992.0_f32));
1071        assert!(
1072            de!(err; permissive::deserialize::<I256, _>, "0x8000000000000000000000000000000000000000000000000000000000000000")
1073        );
1074        assert!(
1075            de!(err; permissive::deserialize::<I256, _>, "-0x8000000000000000000000000000000000000000000000000000000000000001"
1076            )
1077        );
1078
1079        assert!(de!(err; permissive::deserialize::<U256, _>, 4.2_f32));
1080        assert!(de!(err; permissive::deserialize::<U256, _>, 16777216.0_f32));
1081        assert!(de!(err; permissive::deserialize::<U256, _>, 13.37_f64));
1082        assert!(de!(err; permissive::deserialize::<U256, _>, 9007199254740992.0_f32));
1083        assert!(
1084            de!(err; permissive::deserialize::<U256, _>, "0x10000000000000000000000000000000000000000000000000000000000000000")
1085        );
1086
1087        assert_de_bytes!(
1088            bytes::le::deserialize::<U256, _>, [0x00; 32];
1089            eq: U256::ZERO
1090        );
1091        assert_de_bytes!(
1092            bytes::le::deserialize::<U256, _>, [0xff; 32];
1093            eq: U256::MAX
1094        );
1095
1096        assert_de_bytes!(
1097            bytes::le::deserialize::<I256, _>, [0x00; 32];
1098            eq: I256::ZERO
1099        );
1100        assert_de_bytes!(
1101            bytes::le::deserialize::<I256, _>, [0xff; 32];
1102            eq: I256::new(-1)
1103        );
1104
1105        let forty_two = {
1106            let mut v = [0x00; 32];
1107            v[0] = 0x2a;
1108            v
1109        };
1110        assert_de_bytes!(
1111            bytes::le::deserialize::<U256, _>, forty_two;
1112            eq: U256::new(42)
1113        );
1114        assert_de_bytes!(
1115            bytes::le::deserialize::<I256, _>, forty_two;
1116            eq: I256::new(42)
1117        );
1118
1119        assert_de_bytes!(
1120            bytes::le::deserialize::<U256, _>, [0xff; 31];
1121            err
1122        );
1123        assert_de_bytes!(
1124            bytes::le::deserialize::<U256, _>, [0xff; 33];
1125            err
1126        );
1127        assert_de_bytes!(
1128            bytes::le::deserialize::<I256, _>, [0xff; 31];
1129            err
1130        );
1131        assert_de_bytes!(
1132            bytes::le::deserialize::<I256, _>, [0xff; 33];
1133            err
1134        );
1135
1136        assert_de_bytes!(
1137            bytes::be::deserialize::<U256, _>, [0x00; 32];
1138            eq: U256::ZERO
1139        );
1140        assert_de_bytes!(
1141            bytes::be::deserialize::<U256, _>, [0xff; 32];
1142            eq: U256::MAX
1143        );
1144
1145        assert_de_bytes!(
1146            bytes::be::deserialize::<I256, _>, [0x00; 32];
1147            eq: I256::ZERO
1148        );
1149        assert_de_bytes!(
1150            bytes::be::deserialize::<I256, _>, [0xff; 32];
1151            eq: I256::new(-1)
1152        );
1153
1154        let forty_two = {
1155            let mut v = [0x00; 32];
1156            v[31] = 0x2a;
1157            v
1158        };
1159        assert_de_bytes!(
1160            bytes::be::deserialize::<U256, _>, forty_two;
1161            eq: U256::new(42)
1162        );
1163        assert_de_bytes!(
1164            bytes::be::deserialize::<I256, _>, forty_two;
1165            eq: I256::new(42)
1166        );
1167
1168        assert_de_bytes!(
1169            bytes::be::deserialize::<U256, _>, [0xff; 31];
1170            err
1171        );
1172        assert_de_bytes!(
1173            bytes::be::deserialize::<U256, _>, [0xff; 33];
1174            err
1175        );
1176        assert_de_bytes!(
1177            bytes::be::deserialize::<I256, _>, [0xff; 31];
1178            err
1179        );
1180        assert_de_bytes!(
1181            bytes::be::deserialize::<I256, _>, [0xff; 33];
1182            err
1183        );
1184
1185        assert_de_bytes!(
1186            compressed_bytes::le::deserialize::<U256, _>, [];
1187            eq: U256::ZERO
1188        );
1189        assert_de_bytes!(
1190            compressed_bytes::le::deserialize::<U256, _>, [0xff; 32];
1191            eq: U256::MAX
1192        );
1193
1194        assert_de_bytes!(
1195            compressed_bytes::le::deserialize::<U256, _>, [0x2a];
1196            eq: U256::new(42)
1197        );
1198        assert_de_bytes!(
1199            compressed_bytes::le::deserialize::<U256, _>, [0xee, 0xff];
1200            eq: U256::new(0xffee)
1201        );
1202        assert_de_bytes!(
1203            compressed_bytes::le::deserialize::<I256, _>, [];
1204            eq: I256::ZERO
1205        );
1206        assert_de_bytes!(
1207            compressed_bytes::le::deserialize::<I256, _>, [0xff];
1208            eq: I256::new(-1)
1209        );
1210
1211        assert_de_bytes!(
1212            compressed_bytes::le::deserialize::<U256, _>, [0xff; 33];
1213            err
1214        );
1215        assert_de_bytes!(
1216            compressed_bytes::le::deserialize::<I256, _>, [0xff; 33];
1217            err
1218        );
1219
1220        assert_de_bytes!(
1221            compressed_bytes::be::deserialize::<U256, _>, [];
1222            eq: U256::ZERO
1223        );
1224        assert_de_bytes!(
1225            compressed_bytes::be::deserialize::<U256, _>, [0xff; 32];
1226            eq: U256::MAX
1227        );
1228
1229        assert_de_bytes!(
1230            compressed_bytes::be::deserialize::<U256, _>, [0x2a];
1231            eq: U256::new(42)
1232        );
1233        assert_de_bytes!(
1234            compressed_bytes::be::deserialize::<U256, _>, [0xff, 0xee];
1235            eq: U256::new(0xffee)
1236        );
1237        assert_de_bytes!(
1238            compressed_bytes::be::deserialize::<I256, _>, [];
1239            eq: I256::ZERO
1240        );
1241        assert_de_bytes!(
1242            compressed_bytes::be::deserialize::<I256, _>, [0xfe];
1243            eq: I256::new(-2)
1244        );
1245
1246        assert_de_bytes!(
1247            compressed_bytes::be::deserialize::<U256, _>, [0xff; 33];
1248            err
1249        );
1250        assert_de_bytes!(
1251            compressed_bytes::be::deserialize::<I256, _>, [0xff; 33];
1252            err
1253        );
1254    }
1255
1256    #[test]
1257    fn formatting_buffer() {
1258        for value in [
1259            Box::new(I256::MIN) as Box<dyn Display>,
1260            Box::new(I256::MAX),
1261            Box::new(U256::MIN),
1262            Box::new(U256::MAX),
1263        ] {
1264            let mut f = FormatBuffer::decimal();
1265            write!(f, "{value}").unwrap();
1266            assert_eq!(f.as_str(), format!("{value}"));
1267        }
1268
1269        for value in [
1270            Box::new(I256::MIN) as Box<dyn LowerHex>,
1271            Box::new(I256::MAX),
1272            Box::new(U256::MIN),
1273            Box::new(U256::MAX),
1274        ] {
1275            let mut f = FormatBuffer::hex();
1276            let value = &*value;
1277            write!(f, "{value:-#x}").unwrap();
1278            assert_eq!(f.as_str(), format!("{value:-#x}"));
1279        }
1280    }
1281
1282    /// A string serializer used for testing.
1283    struct StringSerializer;
1284
1285    impl Serializer for StringSerializer {
1286        type Ok = String;
1287        type Error = fmt::Error;
1288        type SerializeSeq = Impossible<String, fmt::Error>;
1289        type SerializeTuple = Impossible<String, fmt::Error>;
1290        type SerializeTupleStruct = Impossible<String, fmt::Error>;
1291        type SerializeTupleVariant = Impossible<String, fmt::Error>;
1292        type SerializeMap = Impossible<String, fmt::Error>;
1293        type SerializeStruct = Impossible<String, fmt::Error>;
1294        type SerializeStructVariant = Impossible<String, fmt::Error>;
1295        fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
1296            unimplemented!()
1297        }
1298        fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
1299            unimplemented!()
1300        }
1301        fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
1302            unimplemented!()
1303        }
1304        fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
1305            unimplemented!()
1306        }
1307        fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
1308            unimplemented!()
1309        }
1310        fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
1311            unimplemented!()
1312        }
1313        fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
1314            unimplemented!()
1315        }
1316        fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
1317            unimplemented!()
1318        }
1319        fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
1320            unimplemented!()
1321        }
1322        fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
1323            unimplemented!()
1324        }
1325        fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
1326            unimplemented!()
1327        }
1328        fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
1329            unimplemented!()
1330        }
1331        fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
1332            Ok(v.into())
1333        }
1334        fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
1335            unimplemented!()
1336        }
1337        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
1338            unimplemented!()
1339        }
1340        fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
1341        where
1342            T: Serialize + ?Sized,
1343        {
1344            unimplemented!()
1345        }
1346        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
1347            unimplemented!()
1348        }
1349        fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
1350            unimplemented!()
1351        }
1352        fn serialize_unit_variant(
1353            self,
1354            _: &'static str,
1355            _: u32,
1356            _: &'static str,
1357        ) -> Result<Self::Ok, Self::Error> {
1358            unimplemented!()
1359        }
1360        fn serialize_newtype_struct<T>(
1361            self,
1362            _: &'static str,
1363            _: &T,
1364        ) -> Result<Self::Ok, Self::Error>
1365        where
1366            T: Serialize + ?Sized,
1367        {
1368            unimplemented!()
1369        }
1370        fn serialize_newtype_variant<T>(
1371            self,
1372            _: &'static str,
1373            _: u32,
1374            _: &'static str,
1375            _: &T,
1376        ) -> Result<Self::Ok, Self::Error>
1377        where
1378            T: Serialize + ?Sized,
1379        {
1380            unimplemented!()
1381        }
1382        fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
1383            unimplemented!()
1384        }
1385        fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
1386            unimplemented!()
1387        }
1388        fn serialize_tuple_struct(
1389            self,
1390            _: &'static str,
1391            _: usize,
1392        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
1393            unimplemented!()
1394        }
1395        fn serialize_tuple_variant(
1396            self,
1397            _: &'static str,
1398            _: u32,
1399            _: &'static str,
1400            _: usize,
1401        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
1402            unimplemented!()
1403        }
1404        fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
1405            unimplemented!()
1406        }
1407        fn serialize_struct(
1408            self,
1409            _: &'static str,
1410            _: usize,
1411        ) -> Result<Self::SerializeStruct, Self::Error> {
1412            unimplemented!()
1413        }
1414        fn serialize_struct_variant(
1415            self,
1416            _: &'static str,
1417            _: u32,
1418            _: &'static str,
1419            _: usize,
1420        ) -> Result<Self::SerializeStructVariant, Self::Error> {
1421            unimplemented!()
1422        }
1423        fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
1424        where
1425            T: Display + ?Sized,
1426        {
1427            unimplemented!()
1428        }
1429    }
1430
1431    /// A string serializer used for testing.
1432    struct BytesSerializer;
1433
1434    impl Serializer for BytesSerializer {
1435        type Ok = Vec<u8>;
1436        type Error = fmt::Error;
1437        type SerializeSeq = Impossible<Vec<u8>, fmt::Error>;
1438        type SerializeTuple = Impossible<Vec<u8>, fmt::Error>;
1439        type SerializeTupleStruct = Impossible<Vec<u8>, fmt::Error>;
1440        type SerializeTupleVariant = Impossible<Vec<u8>, fmt::Error>;
1441        type SerializeMap = Impossible<Vec<u8>, fmt::Error>;
1442        type SerializeStruct = Impossible<Vec<u8>, fmt::Error>;
1443        type SerializeStructVariant = Impossible<Vec<u8>, fmt::Error>;
1444        fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
1445            unimplemented!()
1446        }
1447        fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
1448            unimplemented!()
1449        }
1450        fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
1451            unimplemented!()
1452        }
1453        fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
1454            unimplemented!()
1455        }
1456        fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
1457            unimplemented!()
1458        }
1459        fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
1460            unimplemented!()
1461        }
1462        fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
1463            unimplemented!()
1464        }
1465        fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
1466            unimplemented!()
1467        }
1468        fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
1469            unimplemented!()
1470        }
1471        fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
1472            unimplemented!()
1473        }
1474        fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
1475            unimplemented!()
1476        }
1477        fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
1478            unimplemented!()
1479        }
1480        fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
1481            unimplemented!()
1482        }
1483        fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
1484            Ok(v.to_vec())
1485        }
1486        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
1487            unimplemented!()
1488        }
1489        fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
1490        where
1491            T: Serialize + ?Sized,
1492        {
1493            unimplemented!()
1494        }
1495        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
1496            unimplemented!()
1497        }
1498        fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
1499            unimplemented!()
1500        }
1501        fn serialize_unit_variant(
1502            self,
1503            _: &'static str,
1504            _: u32,
1505            _: &'static str,
1506        ) -> Result<Self::Ok, Self::Error> {
1507            unimplemented!()
1508        }
1509        fn serialize_newtype_struct<T>(
1510            self,
1511            _: &'static str,
1512            _: &T,
1513        ) -> Result<Self::Ok, Self::Error>
1514        where
1515            T: Serialize + ?Sized,
1516        {
1517            unimplemented!()
1518        }
1519        fn serialize_newtype_variant<T>(
1520            self,
1521            _: &'static str,
1522            _: u32,
1523            _: &'static str,
1524            _: &T,
1525        ) -> Result<Self::Ok, Self::Error>
1526        where
1527            T: Serialize + ?Sized,
1528        {
1529            unimplemented!()
1530        }
1531        fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
1532            unimplemented!()
1533        }
1534        fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
1535            unimplemented!()
1536        }
1537        fn serialize_tuple_struct(
1538            self,
1539            _: &'static str,
1540            _: usize,
1541        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
1542            unimplemented!()
1543        }
1544        fn serialize_tuple_variant(
1545            self,
1546            _: &'static str,
1547            _: u32,
1548            _: &'static str,
1549            _: usize,
1550        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
1551            unimplemented!()
1552        }
1553        fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
1554            unimplemented!()
1555        }
1556        fn serialize_struct(
1557            self,
1558            _: &'static str,
1559            _: usize,
1560        ) -> Result<Self::SerializeStruct, Self::Error> {
1561            unimplemented!()
1562        }
1563        fn serialize_struct_variant(
1564            self,
1565            _: &'static str,
1566            _: u32,
1567            _: &'static str,
1568            _: usize,
1569        ) -> Result<Self::SerializeStructVariant, Self::Error> {
1570            unimplemented!()
1571        }
1572        fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
1573        where
1574            T: Display + ?Sized,
1575        {
1576            unimplemented!()
1577        }
1578    }
1579}
ethnum/serde.rs

ethnum/
serde.rs
