borsh/de/
mod.rs

Help
1use core::marker::PhantomData;
2use core::mem::MaybeUninit;
3use core::{
4    convert::{TryFrom, TryInto},
5    mem::size_of,
6};
7
8#[cfg(feature = "bytes")]
9use bytes::{BufMut, BytesMut};
10
11use crate::__private::maybestd::{
12    borrow::{Borrow, Cow, ToOwned},
13    boxed::Box,
14    collections::{BTreeMap, BTreeSet, LinkedList, VecDeque},
15    format,
16    string::{String, ToString},
17    vec,
18    vec::Vec,
19};
20use crate::io::{Error, ErrorKind, Read, Result};
21
22use crate::error::check_zst;
23
24mod hint;
25
26const ERROR_NOT_ALL_BYTES_READ: &str = "Not all bytes read";
27const ERROR_UNEXPECTED_LENGTH_OF_INPUT: &str = "Unexpected length of input";
28const ERROR_OVERFLOW_ON_MACHINE_WITH_32_BIT_ISIZE: &str = "Overflow on machine with 32 bit isize";
29const ERROR_OVERFLOW_ON_MACHINE_WITH_32_BIT_USIZE: &str = "Overflow on machine with 32 bit usize";
30const ERROR_INVALID_ZERO_VALUE: &str = "Expected a non-zero value";
31
32#[cfg(feature = "de_strict_order")]
33const ERROR_WRONG_ORDER_OF_KEYS: &str = "keys were not serialized in ascending order";
34
35/// A data-structure that can be de-serialized from binary format by NBOR.
36pub trait BorshDeserialize: Sized {
37    /// Deserializes this instance from a given slice of bytes.
38    /// Updates the buffer to point at the remaining bytes.
39    fn deserialize(buf: &mut &[u8]) -> Result<Self> {
40        Self::deserialize_reader(&mut *buf)
41    }
42
43    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self>;
44
45    /// Deserialize this instance from a slice of bytes.
46    fn try_from_slice(v: &[u8]) -> Result<Self> {
47        let mut v_mut = v;
48        let result = Self::deserialize(&mut v_mut)?;
49        if !v_mut.is_empty() {
50            return Err(Error::new(ErrorKind::InvalidData, ERROR_NOT_ALL_BYTES_READ));
51        }
52        Ok(result)
53    }
54
55    fn try_from_reader<R: Read>(reader: &mut R) -> Result<Self> {
56        let result = Self::deserialize_reader(reader)?;
57        let mut buf = [0u8; 1];
58        match reader.read_exact(&mut buf) {
59            Err(f) if f.kind() == ErrorKind::UnexpectedEof => Ok(result),
60            _ => Err(Error::new(ErrorKind::InvalidData, ERROR_NOT_ALL_BYTES_READ)),
61        }
62    }
63
64    #[inline]
65    #[doc(hidden)]
66    fn vec_from_reader<R: Read>(len: u32, reader: &mut R) -> Result<Option<Vec<Self>>> {
67        let _ = len;
68        let _ = reader;
69        Ok(None)
70    }
71
72    #[inline]
73    #[doc(hidden)]
74    fn array_from_reader<R: Read, const N: usize>(reader: &mut R) -> Result<Option<[Self; N]>> {
75        let _ = reader;
76        Ok(None)
77    }
78}
79
80/// Additional methods offered on enums which is used by `[derive(BorshDeserialize)]`.
81pub trait EnumExt: BorshDeserialize {
82    /// Deserialises given variant of an enum from the reader.
83    ///
84    /// This may be used to perform validation or filtering based on what
85    /// variant is being deserialised.
86    ///
87    /// ```
88    /// use borsh::BorshDeserialize;
89    /// use borsh::de::EnumExt as _;
90    ///
91    /// /// derive is only available if borsh is built with `features = ["derive"]`
92    /// # #[cfg(feature = "derive")]
93    /// #[derive(Debug, PartialEq, Eq, BorshDeserialize)]
94    /// enum MyEnum {
95    ///     Zero,
96    ///     One(u8),
97    ///     Many(Vec<u8>)
98    /// }
99    ///
100    /// # #[cfg(feature = "derive")]
101    /// #[derive(Debug, PartialEq, Eq)]
102    /// struct OneOrZero(MyEnum);
103    ///
104    /// # #[cfg(feature = "derive")]
105    /// impl borsh::de::BorshDeserialize for OneOrZero {
106    ///     fn deserialize_reader<R: borsh::io::Read>(
107    ///         reader: &mut R,
108    ///     ) -> borsh::io::Result<Self> {
109    ///         use borsh::de::EnumExt;
110    ///         let tag = u8::deserialize_reader(reader)?;
111    ///         if tag == 2 {
112    ///             Err(borsh::io::Error::new(
113    ///                 borsh::io::ErrorKind::InvalidData,
114    ///                 "MyEnum::Many not allowed here",
115    ///             ))
116    ///         } else {
117    ///             MyEnum::deserialize_variant(reader, tag).map(Self)
118    ///         }
119    ///     }
120    /// }
121    ///
122    /// use borsh::from_slice;
123    /// let data = b"\0";
124    /// # #[cfg(feature = "derive")]
125    /// assert_eq!(MyEnum::Zero, from_slice::<MyEnum>(&data[..]).unwrap());
126    /// # #[cfg(feature = "derive")]
127    /// assert_eq!(MyEnum::Zero, from_slice::<OneOrZero>(&data[..]).unwrap().0);
128    ///
129    /// let data = b"\x02\0\0\0\0";
130    /// # #[cfg(feature = "derive")]
131    /// assert_eq!(MyEnum::Many(Vec::new()), from_slice::<MyEnum>(&data[..]).unwrap());
132    /// # #[cfg(feature = "derive")]
133    /// assert!(from_slice::<OneOrZero>(&data[..]).is_err());
134    /// ```
135    fn deserialize_variant<R: Read>(reader: &mut R, tag: u8) -> Result<Self>;
136}
137
138fn unexpected_eof_to_unexpected_length_of_input(e: Error) -> Error {
139    if e.kind() == ErrorKind::UnexpectedEof {
140        Error::new(ErrorKind::InvalidData, ERROR_UNEXPECTED_LENGTH_OF_INPUT)
141    } else {
142        e
143    }
144}
145
146impl BorshDeserialize for u8 {
147    #[inline]
148    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
149        let mut buf = [0u8; 1];
150        reader
151            .read_exact(&mut buf)
152            .map_err(unexpected_eof_to_unexpected_length_of_input)?;
153        Ok(buf[0])
154    }
155
156    #[inline]
157    #[doc(hidden)]
158    fn vec_from_reader<R: Read>(len: u32, reader: &mut R) -> Result<Option<Vec<Self>>> {
159        let len: usize = len.try_into().map_err(|_| ErrorKind::InvalidData)?;
160        // Avoid OOM by limiting the size of allocation.  This makes the read
161        // less efficient (since we need to loop and reallocate) but it protects
162        // us from someone sending us [0xff, 0xff, 0xff, 0xff] and forcing us to
163        // allocate 4GiB of memory.
164        let mut vec = vec![0u8; len.min(1024 * 1024)];
165        let mut pos = 0;
166        while pos < len {
167            if pos == vec.len() {
168                vec.resize(vec.len().saturating_mul(2).min(len), 0)
169            }
170            // TODO(mina86): Convert this to read_buf once that stabilises.
171            match reader.read(&mut vec.as_mut_slice()[pos..])? {
172                0 => {
173                    return Err(Error::new(
174                        ErrorKind::InvalidData,
175                        ERROR_UNEXPECTED_LENGTH_OF_INPUT,
176                    ))
177                }
178                read => {
179                    pos += read;
180                }
181            }
182        }
183        Ok(Some(vec))
184    }
185
186    #[inline]
187    #[doc(hidden)]
188    fn array_from_reader<R: Read, const N: usize>(reader: &mut R) -> Result<Option<[Self; N]>> {
189        let mut arr = [0u8; N];
190        reader
191            .read_exact(&mut arr)
192            .map_err(unexpected_eof_to_unexpected_length_of_input)?;
193        Ok(Some(arr))
194    }
195}
196
197macro_rules! impl_for_integer {
198    ($type: ident) => {
199        impl BorshDeserialize for $type {
200            #[inline]
201            fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
202                let mut buf = [0u8; size_of::<$type>()];
203                reader
204                    .read_exact(&mut buf)
205                    .map_err(unexpected_eof_to_unexpected_length_of_input)?;
206                let res = $type::from_le_bytes(buf.try_into().unwrap());
207                Ok(res)
208            }
209        }
210    };
211}
212
213impl_for_integer!(i8);
214impl_for_integer!(i16);
215impl_for_integer!(i32);
216impl_for_integer!(i64);
217impl_for_integer!(i128);
218impl_for_integer!(u16);
219impl_for_integer!(u32);
220impl_for_integer!(u64);
221impl_for_integer!(u128);
222
223macro_rules! impl_for_nonzero_integer {
224    ($type: ty) => {
225        impl BorshDeserialize for $type {
226            #[inline]
227            fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
228                <$type>::new(BorshDeserialize::deserialize_reader(reader)?)
229                    .ok_or_else(|| Error::new(ErrorKind::InvalidData, ERROR_INVALID_ZERO_VALUE))
230            }
231        }
232    };
233}
234
235impl_for_nonzero_integer!(core::num::NonZeroI8);
236impl_for_nonzero_integer!(core::num::NonZeroI16);
237impl_for_nonzero_integer!(core::num::NonZeroI32);
238impl_for_nonzero_integer!(core::num::NonZeroI64);
239impl_for_nonzero_integer!(core::num::NonZeroI128);
240impl_for_nonzero_integer!(core::num::NonZeroU8);
241impl_for_nonzero_integer!(core::num::NonZeroU16);
242impl_for_nonzero_integer!(core::num::NonZeroU32);
243impl_for_nonzero_integer!(core::num::NonZeroU64);
244impl_for_nonzero_integer!(core::num::NonZeroU128);
245impl_for_nonzero_integer!(core::num::NonZeroUsize);
246
247impl BorshDeserialize for isize {
248    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
249        let i: i64 = BorshDeserialize::deserialize_reader(reader)?;
250        let i = isize::try_from(i).map_err(|_| {
251            Error::new(
252                ErrorKind::InvalidData,
253                ERROR_OVERFLOW_ON_MACHINE_WITH_32_BIT_ISIZE,
254            )
255        })?;
256        Ok(i)
257    }
258}
259
260impl BorshDeserialize for usize {
261    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
262        let u: u64 = BorshDeserialize::deserialize_reader(reader)?;
263        let u = usize::try_from(u).map_err(|_| {
264            Error::new(
265                ErrorKind::InvalidData,
266                ERROR_OVERFLOW_ON_MACHINE_WITH_32_BIT_USIZE,
267            )
268        })?;
269        Ok(u)
270    }
271}
272
273// Note NaNs have a portability issue. Specifically, signalling NaNs on MIPS are quiet NaNs on x86,
274// and vice-versa. We disallow NaNs to avoid this issue.
275macro_rules! impl_for_float {
276    ($type: ident, $int_type: ident) => {
277        impl BorshDeserialize for $type {
278            #[inline]
279            fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
280                let mut buf = [0u8; size_of::<$type>()];
281                reader
282                    .read_exact(&mut buf)
283                    .map_err(unexpected_eof_to_unexpected_length_of_input)?;
284                let res = $type::from_bits($int_type::from_le_bytes(buf.try_into().unwrap()));
285                if res.is_nan() {
286                    return Err(Error::new(
287                        ErrorKind::InvalidData,
288                        "For portability reasons we do not allow to deserialize NaNs.",
289                    ));
290                }
291                Ok(res)
292            }
293        }
294    };
295}
296
297impl_for_float!(f32, u32);
298impl_for_float!(f64, u64);
299
300impl BorshDeserialize for bool {
301    #[inline]
302    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
303        let b: u8 = BorshDeserialize::deserialize_reader(reader)?;
304        if b == 0 {
305            Ok(false)
306        } else if b == 1 {
307            Ok(true)
308        } else {
309            let msg = format!("Invalid bool representation: {}", b);
310
311            Err(Error::new(ErrorKind::InvalidData, msg))
312        }
313    }
314}
315
316impl<T> BorshDeserialize for Option<T>
317where
318    T: BorshDeserialize,
319{
320    #[inline]
321    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
322        let flag: u8 = BorshDeserialize::deserialize_reader(reader)?;
323        if flag == 0 {
324            Ok(None)
325        } else if flag == 1 {
326            Ok(Some(T::deserialize_reader(reader)?))
327        } else {
328            let msg = format!(
329                "Invalid Option representation: {}. The first byte must be 0 or 1",
330                flag
331            );
332
333            Err(Error::new(ErrorKind::InvalidData, msg))
334        }
335    }
336}
337
338impl<T, E> BorshDeserialize for core::result::Result<T, E>
339where
340    T: BorshDeserialize,
341    E: BorshDeserialize,
342{
343    #[inline]
344    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
345        let flag: u8 = BorshDeserialize::deserialize_reader(reader)?;
346        if flag == 0 {
347            Ok(Err(E::deserialize_reader(reader)?))
348        } else if flag == 1 {
349            Ok(Ok(T::deserialize_reader(reader)?))
350        } else {
351            let msg = format!(
352                "Invalid Result representation: {}. The first byte must be 0 or 1",
353                flag
354            );
355
356            Err(Error::new(ErrorKind::InvalidData, msg))
357        }
358    }
359}
360
361impl BorshDeserialize for String {
362    #[inline]
363    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
364        String::from_utf8(Vec::<u8>::deserialize_reader(reader)?).map_err(|err| {
365            let msg = err.to_string();
366            Error::new(ErrorKind::InvalidData, msg)
367        })
368    }
369}
370
371/// Module is available if borsh is built with `features = ["ascii"]`.
372#[cfg(feature = "ascii")]
373pub mod ascii {
374    //!
375    //! Module defines [BorshDeserialize] implementation for
376    //! some types from [ascii](::ascii) crate.
377    use crate::BorshDeserialize;
378    use crate::__private::maybestd::{string::ToString, vec::Vec};
379    use crate::io::{Error, ErrorKind, Read, Result};
380
381    impl BorshDeserialize for ascii::AsciiString {
382        #[inline]
383        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
384            let bytes = Vec::<u8>::deserialize_reader(reader)?;
385            ascii::AsciiString::from_ascii(bytes)
386                .map_err(|err| Error::new(ErrorKind::InvalidData, err.to_string()))
387        }
388    }
389
390    impl BorshDeserialize for ascii::AsciiChar {
391        #[inline]
392        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
393            let byte = u8::deserialize_reader(reader)?;
394            ascii::AsciiChar::from_ascii(byte)
395                .map_err(|err| Error::new(ErrorKind::InvalidData, err.to_string()))
396        }
397    }
398}
399
400impl<T> BorshDeserialize for Vec<T>
401where
402    T: BorshDeserialize,
403{
404    #[inline]
405    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
406        check_zst::<T>()?;
407
408        let len = u32::deserialize_reader(reader)?;
409        if len == 0 {
410            Ok(Vec::new())
411        } else if let Some(vec_bytes) = T::vec_from_reader(len, reader)? {
412            Ok(vec_bytes)
413        } else {
414            // TODO(16): return capacity allocation when we can safely do that.
415            let mut result = Vec::with_capacity(hint::cautious::<T>(len));
416            for _ in 0..len {
417                result.push(T::deserialize_reader(reader)?);
418            }
419            Ok(result)
420        }
421    }
422}
423
424#[cfg(feature = "bytes")]
425impl BorshDeserialize for bytes::Bytes {
426    #[inline]
427    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
428        let vec = <Vec<u8>>::deserialize_reader(reader)?;
429        Ok(vec.into())
430    }
431}
432
433#[cfg(feature = "bytes")]
434impl BorshDeserialize for bytes::BytesMut {
435    #[inline]
436    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
437        let len = u32::deserialize_reader(reader)?;
438        let mut out = BytesMut::with_capacity(hint::cautious::<u8>(len));
439        for _ in 0..len {
440            out.put_u8(u8::deserialize_reader(reader)?);
441        }
442        Ok(out)
443    }
444}
445
446#[cfg(feature = "bson")]
447impl BorshDeserialize for bson::oid::ObjectId {
448    #[inline]
449    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
450        let mut buf = [0u8; 12];
451        reader.read_exact(&mut buf)?;
452        Ok(bson::oid::ObjectId::from_bytes(buf))
453    }
454}
455
456#[cfg(feature = "indexmap")]
457// Taken from https://github.com/indexmap-rs/indexmap/blob/dd06e5773e4f91748396c67d00c83637f5c0dd49/src/borsh.rs#L39
458// license: MIT OR Apache-2.0
459impl<K, V, S> BorshDeserialize for indexmap::IndexMap<K, V, S>
460where
461    K: BorshDeserialize + Eq + core::hash::Hash,
462    V: BorshDeserialize,
463    S: core::hash::BuildHasher + Default,
464{
465    #[inline]
466    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
467        check_zst::<K>()?;
468        let vec = <Vec<(K, V)>>::deserialize_reader(reader)?;
469        Ok(vec.into_iter().collect::<indexmap::IndexMap<K, V, S>>())
470    }
471}
472
473#[cfg(feature = "indexmap")]
474// Taken from https://github.com/indexmap-rs/indexmap/blob/dd06e5773e4f91748396c67d00c83637f5c0dd49/src/borsh.rs#L75
475// license: MIT OR Apache-2.0
476impl<T, S> BorshDeserialize for indexmap::IndexSet<T, S>
477where
478    T: BorshDeserialize + Eq + core::hash::Hash,
479    S: core::hash::BuildHasher + Default,
480{
481    #[inline]
482    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
483        check_zst::<T>()?;
484        let vec = <Vec<T>>::deserialize_reader(reader)?;
485        Ok(vec.into_iter().collect::<indexmap::IndexSet<T, S>>())
486    }
487}
488
489impl<T> BorshDeserialize for Cow<'_, T>
490where
491    T: ToOwned + ?Sized,
492    T::Owned: BorshDeserialize,
493{
494    #[inline]
495    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
496        Ok(Cow::Owned(BorshDeserialize::deserialize_reader(reader)?))
497    }
498}
499
500impl<T> BorshDeserialize for VecDeque<T>
501where
502    T: BorshDeserialize,
503{
504    #[inline]
505    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
506        let vec = <Vec<T>>::deserialize_reader(reader)?;
507        Ok(vec.into())
508    }
509}
510
511impl<T> BorshDeserialize for LinkedList<T>
512where
513    T: BorshDeserialize,
514{
515    #[inline]
516    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
517        let vec = <Vec<T>>::deserialize_reader(reader)?;
518        Ok(vec.into_iter().collect::<LinkedList<T>>())
519    }
520}
521
522/// Module is available if borsh is built with `features = ["std"]` or `features = ["hashbrown"]`.
523///
524/// Module defines [BorshDeserialize] implementation for
525/// [HashMap](std::collections::HashMap)/[HashSet](std::collections::HashSet).
526#[cfg(hash_collections)]
527pub mod hashes {
528    use core::hash::{BuildHasher, Hash};
529
530    use crate::BorshDeserialize;
531    use crate::__private::maybestd::collections::{HashMap, HashSet};
532    use crate::__private::maybestd::vec::Vec;
533    use crate::io::{Read, Result};
534
535    #[cfg(feature = "de_strict_order")]
536    const ERROR_WRONG_ORDER_OF_KEYS: &str = "keys were not serialized in ascending order";
537    use crate::error::check_zst;
538    #[cfg(feature = "de_strict_order")]
539    use crate::io::{Error, ErrorKind};
540
541    impl<T, H> BorshDeserialize for HashSet<T, H>
542    where
543        T: BorshDeserialize + Eq + Hash + Ord,
544        H: BuildHasher + Default,
545    {
546        #[inline]
547        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
548            // NOTE: deserialize-as-you-go approach as once was in HashSet is better in the sense
549            // that it allows to fail early, and not allocate memory for all the elements
550            // which may fail `cmp()` checks
551            // NOTE: deserialize first to `Vec<T>` is faster
552            let vec = <Vec<T>>::deserialize_reader(reader)?;
553
554            #[cfg(feature = "de_strict_order")]
555            // TODO: replace with `is_sorted` api when stabilizes https://github.com/rust-lang/rust/issues/53485
556            // TODO: first replace with `array_windows` api when stabilizes https://github.com/rust-lang/rust/issues/75027
557            for pair in vec.windows(2) {
558                let [a, b] = pair else {
559                    unreachable!("`windows` always return a slice of length 2 or nothing");
560                };
561                let cmp_result = a.cmp(b).is_lt();
562                if !cmp_result {
563                    return Err(Error::new(
564                        ErrorKind::InvalidData,
565                        ERROR_WRONG_ORDER_OF_KEYS,
566                    ));
567                }
568            }
569
570            Ok(vec.into_iter().collect::<HashSet<T, H>>())
571        }
572    }
573
574    impl<K, V, H> BorshDeserialize for HashMap<K, V, H>
575    where
576        K: BorshDeserialize + Eq + Hash + Ord,
577        V: BorshDeserialize,
578        H: BuildHasher + Default,
579    {
580        #[inline]
581        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
582            check_zst::<K>()?;
583            // NOTE: deserialize-as-you-go approach as once was in HashSet is better in the sense
584            // that it allows to fail early, and not allocate memory for all the entries
585            // which may fail `cmp()` checks
586            // NOTE: deserialize first to `Vec<(K, V)>` is faster
587            let vec = <Vec<(K, V)>>::deserialize_reader(reader)?;
588
589            #[cfg(feature = "de_strict_order")]
590            // TODO: replace with `is_sorted` api when stabilizes https://github.com/rust-lang/rust/issues/53485
591            // TODO: first replace with `array_windows` api when stabilizes https://github.com/rust-lang/rust/issues/75027
592            for pair in vec.windows(2) {
593                let [(a_k, _a_v), (b_k, _b_v)] = pair else {
594                    unreachable!("`windows` always return a slice of length 2 or nothing");
595                };
596                let cmp_result = a_k.cmp(b_k).is_lt();
597                if !cmp_result {
598                    return Err(Error::new(
599                        ErrorKind::InvalidData,
600                        ERROR_WRONG_ORDER_OF_KEYS,
601                    ));
602                }
603            }
604
605            Ok(vec.into_iter().collect::<HashMap<K, V, H>>())
606        }
607    }
608}
609
610impl<T> BorshDeserialize for BTreeSet<T>
611where
612    T: BorshDeserialize + Ord,
613{
614    #[inline]
615    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
616        // NOTE: deserialize-as-you-go approach as once was in HashSet is better in the sense
617        // that it allows to fail early, and not allocate memory for all the elements
618        // which may fail `cmp()` checks
619        // NOTE: deserialize first to `Vec<T>` is faster
620        let vec = <Vec<T>>::deserialize_reader(reader)?;
621
622        #[cfg(feature = "de_strict_order")]
623        // TODO: replace with `is_sorted` api when stabilizes https://github.com/rust-lang/rust/issues/53485
624        // TODO: first replace with `array_windows` api when stabilizes https://github.com/rust-lang/rust/issues/75027
625        for pair in vec.windows(2) {
626            let [a, b] = pair else {
627                unreachable!("`windows` always return a slice of length 2 or nothing");
628            };
629            let cmp_result = a.cmp(b).is_lt();
630            if !cmp_result {
631                return Err(Error::new(
632                    ErrorKind::InvalidData,
633                    ERROR_WRONG_ORDER_OF_KEYS,
634                ));
635            }
636        }
637        // NOTE: BTreeSet has an optimization inside of impl <T> FromIterator<T> for BTreeSet<T, Global>,
638        // based on BTreeMap::bulk_build_from_sorted_iter
639        Ok(vec.into_iter().collect::<BTreeSet<T>>())
640    }
641}
642
643impl<K, V> BorshDeserialize for BTreeMap<K, V>
644where
645    K: BorshDeserialize + Ord,
646    V: BorshDeserialize,
647{
648    #[inline]
649    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
650        check_zst::<K>()?;
651        // NOTE: deserialize-as-you-go approach as once was in HashSet is better in the sense
652        // that it allows to fail early, and not allocate memory for all the entries
653        // which may fail `cmp()` checks
654        // NOTE: deserialize first to `Vec<(K, V)>` is faster
655        let vec = <Vec<(K, V)>>::deserialize_reader(reader)?;
656
657        #[cfg(feature = "de_strict_order")]
658        // TODO: replace with `is_sorted` api when stabilizes https://github.com/rust-lang/rust/issues/53485
659        // TODO: first replace with `array_windows` api when stabilizes https://github.com/rust-lang/rust/issues/75027
660        for pair in vec.windows(2) {
661            let [(a_k, _a_v), (b_k, _b_v)] = pair else {
662                unreachable!("`windows` always return a slice of length 2 or nothing");
663            };
664            let cmp_result = a_k.cmp(b_k).is_lt();
665            if !cmp_result {
666                return Err(Error::new(
667                    ErrorKind::InvalidData,
668                    ERROR_WRONG_ORDER_OF_KEYS,
669                ));
670            }
671        }
672
673        // NOTE: BTreeMap has an optimization inside of impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V, Global>,
674        // based on BTreeMap::bulk_build_from_sorted_iter
675        Ok(vec.into_iter().collect::<BTreeMap<K, V>>())
676    }
677}
678
679#[cfg(feature = "std")]
680impl BorshDeserialize for std::net::SocketAddr {
681    #[inline]
682    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
683        let kind = u8::deserialize_reader(reader)?;
684        match kind {
685            0 => std::net::SocketAddrV4::deserialize_reader(reader).map(std::net::SocketAddr::V4),
686            1 => std::net::SocketAddrV6::deserialize_reader(reader).map(std::net::SocketAddr::V6),
687            value => Err(Error::new(
688                ErrorKind::InvalidData,
689                format!("Invalid SocketAddr variant: {}", value),
690            )),
691        }
692    }
693}
694
695#[cfg(feature = "std")]
696impl BorshDeserialize for std::net::IpAddr {
697    #[inline]
698    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
699        let kind = u8::deserialize_reader(reader)?;
700        match kind {
701            0u8 => {
702                // Deserialize an Ipv4Addr and convert it to IpAddr::V4
703                let ipv4_addr = std::net::Ipv4Addr::deserialize_reader(reader)?;
704                Ok(std::net::IpAddr::V4(ipv4_addr))
705            }
706            1u8 => {
707                // Deserialize an Ipv6Addr and convert it to IpAddr::V6
708                let ipv6_addr = std::net::Ipv6Addr::deserialize_reader(reader)?;
709                Ok(std::net::IpAddr::V6(ipv6_addr))
710            }
711            value => Err(Error::new(
712                ErrorKind::InvalidData,
713                format!("Invalid IpAddr variant: {}", value),
714            )),
715        }
716    }
717}
718
719#[cfg(feature = "std")]
720impl BorshDeserialize for std::net::SocketAddrV4 {
721    #[inline]
722    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
723        let ip = std::net::Ipv4Addr::deserialize_reader(reader)?;
724        let port = u16::deserialize_reader(reader)?;
725        Ok(std::net::SocketAddrV4::new(ip, port))
726    }
727}
728
729#[cfg(feature = "std")]
730impl BorshDeserialize for std::net::SocketAddrV6 {
731    #[inline]
732    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
733        let ip = std::net::Ipv6Addr::deserialize_reader(reader)?;
734        let port = u16::deserialize_reader(reader)?;
735        Ok(std::net::SocketAddrV6::new(ip, port, 0, 0))
736    }
737}
738
739#[cfg(feature = "std")]
740impl BorshDeserialize for std::net::Ipv4Addr {
741    #[inline]
742    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
743        let mut buf = [0u8; 4];
744        reader
745            .read_exact(&mut buf)
746            .map_err(unexpected_eof_to_unexpected_length_of_input)?;
747        Ok(std::net::Ipv4Addr::from(buf))
748    }
749}
750
751#[cfg(feature = "std")]
752impl BorshDeserialize for std::net::Ipv6Addr {
753    #[inline]
754    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
755        let mut buf = [0u8; 16];
756        reader
757            .read_exact(&mut buf)
758            .map_err(unexpected_eof_to_unexpected_length_of_input)?;
759        Ok(std::net::Ipv6Addr::from(buf))
760    }
761}
762
763impl<T, U> BorshDeserialize for Box<T>
764where
765    U: Into<Box<T>> + Borrow<T>,
766    T: ToOwned<Owned = U> + ?Sized,
767    T::Owned: BorshDeserialize,
768{
769    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
770        Ok(T::Owned::deserialize_reader(reader)?.into())
771    }
772}
773
774impl<T, const N: usize> BorshDeserialize for [T; N]
775where
776    T: BorshDeserialize,
777{
778    #[inline]
779    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
780        struct ArrayDropGuard<T, const N: usize> {
781            buffer: [MaybeUninit<T>; N],
782            init_count: usize,
783        }
784        impl<T, const N: usize> Drop for ArrayDropGuard<T, N> {
785            fn drop(&mut self) {
786                let init_range = &mut self.buffer[..self.init_count];
787                // SAFETY: Elements up to self.init_count have been initialized. Assumes this value
788                //         is only incremented in `fill_buffer`, which writes the element before
789                //         increasing the init_count.
790                unsafe {
791                    core::ptr::drop_in_place(init_range as *mut _ as *mut [T]);
792                };
793            }
794        }
795        impl<T, const N: usize> ArrayDropGuard<T, N> {
796            unsafe fn transmute_to_array(mut self) -> [T; N] {
797                debug_assert_eq!(self.init_count, N);
798                // Set init_count to 0 so that the values do not get dropped twice.
799                self.init_count = 0;
800                // SAFETY: This cast is required because `mem::transmute` does not work with
801                //         const generics https://github.com/rust-lang/rust/issues/61956. This
802                //         array is guaranteed to be initialized by this point.
803                core::ptr::read(&self.buffer as *const _ as *const [T; N])
804            }
805            fn fill_buffer(&mut self, mut f: impl FnMut() -> Result<T>) -> Result<()> {
806                // TODO: replace with `core::array::try_from_fn` when stabilized to avoid manually
807                // dropping uninitialized values through the guard drop.
808                for elem in self.buffer.iter_mut() {
809                    elem.write(f()?);
810                    self.init_count += 1;
811                }
812                Ok(())
813            }
814        }
815
816        if let Some(arr) = T::array_from_reader(reader)? {
817            Ok(arr)
818        } else {
819            let mut result = ArrayDropGuard {
820                buffer: unsafe { MaybeUninit::uninit().assume_init() },
821                init_count: 0,
822            };
823
824            result.fill_buffer(|| T::deserialize_reader(reader))?;
825
826            // SAFETY: The elements up to `i` have been initialized in `fill_buffer`.
827            Ok(unsafe { result.transmute_to_array() })
828        }
829    }
830}
831
832#[test]
833fn array_deserialization_doesnt_leak() {
834    use core::sync::atomic::{AtomicUsize, Ordering};
835
836    static DESERIALIZE_COUNT: AtomicUsize = AtomicUsize::new(0);
837    static DROP_COUNT: AtomicUsize = AtomicUsize::new(0);
838
839    #[allow(unused)]
840    struct MyType(u8);
841    impl BorshDeserialize for MyType {
842        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
843            let val = u8::deserialize_reader(reader)?;
844            let v = DESERIALIZE_COUNT.fetch_add(1, Ordering::SeqCst);
845            if v >= 7 {
846                panic!("panic in deserialize");
847            }
848            Ok(MyType(val))
849        }
850    }
851    impl Drop for MyType {
852        fn drop(&mut self) {
853            DROP_COUNT.fetch_add(1, Ordering::SeqCst);
854        }
855    }
856
857    assert!(<[MyType; 5] as BorshDeserialize>::deserialize(&mut &[0u8; 3][..]).is_err());
858    assert_eq!(DESERIALIZE_COUNT.load(Ordering::SeqCst), 3);
859    assert_eq!(DROP_COUNT.load(Ordering::SeqCst), 3);
860
861    assert!(<[MyType; 2] as BorshDeserialize>::deserialize(&mut &[0u8; 2][..]).is_ok());
862    assert_eq!(DESERIALIZE_COUNT.load(Ordering::SeqCst), 5);
863    assert_eq!(DROP_COUNT.load(Ordering::SeqCst), 5);
864
865    #[cfg(feature = "std")]
866    {
867        // Test that during a panic in deserialize, the values are still dropped.
868        let result = std::panic::catch_unwind(|| {
869            <[MyType; 3] as BorshDeserialize>::deserialize(&mut &[0u8; 3][..]).unwrap();
870        });
871        assert!(result.is_err());
872        assert_eq!(DESERIALIZE_COUNT.load(Ordering::SeqCst), 8);
873        assert_eq!(DROP_COUNT.load(Ordering::SeqCst), 7); // 5 because 6 panicked and was not init
874    }
875}
876
877macro_rules! impl_tuple {
878    (@unit $name:ty) => {
879        impl BorshDeserialize for $name {
880            #[inline]
881            fn deserialize_reader<R: Read>(_reader: &mut R) -> Result<Self> {
882                Ok(<$name>::default())
883            }
884        }
885    };
886
887    ($($name:ident)+) => {
888      impl<$($name),+> BorshDeserialize for ($($name,)+)
889      where $($name: BorshDeserialize,)+
890      {
891        #[inline]
892        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
893
894            Ok(($($name::deserialize_reader(reader)?,)+))
895        }
896      }
897    };
898}
899
900impl_tuple!(@unit ());
901impl_tuple!(@unit core::ops::RangeFull);
902
903impl_tuple!(T0);
904impl_tuple!(T0 T1);
905impl_tuple!(T0 T1 T2);
906impl_tuple!(T0 T1 T2 T3);
907impl_tuple!(T0 T1 T2 T3 T4);
908impl_tuple!(T0 T1 T2 T3 T4 T5);
909impl_tuple!(T0 T1 T2 T3 T4 T5 T6);
910impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7);
911impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8);
912impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9);
913impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10);
914impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11);
915impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12);
916impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13);
917impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14);
918impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15);
919impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16);
920impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17);
921impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17 T18);
922impl_tuple!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16 T17 T18 T19);
923
924macro_rules! impl_range {
925    ($type:ident, $make:expr, $($side:ident),*) => {
926        impl<T: BorshDeserialize> BorshDeserialize for core::ops::$type<T> {
927            #[inline]
928            fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
929                let ($($side,)*) = <_>::deserialize_reader(reader)?;
930                Ok($make)
931            }
932        }
933    };
934}
935
936impl_range!(Range, start..end, start, end);
937impl_range!(RangeInclusive, start..=end, start, end);
938impl_range!(RangeFrom, start.., start);
939impl_range!(RangeTo, ..end, end);
940impl_range!(RangeToInclusive, ..=end, end);
941
942/// Module is available if borsh is built with `features = ["rc"]`.
943#[cfg(feature = "rc")]
944pub mod rc {
945    //!
946    //! Module defines [BorshDeserialize] implementation for
947    //! [alloc::rc::Rc](std::rc::Rc) and [alloc::sync::Arc](std::sync::Arc).
948    use crate::__private::maybestd::{boxed::Box, rc::Rc, sync::Arc};
949    use crate::io::{Read, Result};
950    use crate::BorshDeserialize;
951
952    /// This impl requires the [`"rc"`] Cargo feature of borsh.
953    ///
954    /// Deserializing a data structure containing `Rc` will not attempt to
955    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
956    /// will end up with a strong count of 1.
957    impl<T: ?Sized> BorshDeserialize for Rc<T>
958    where
959        Box<T>: BorshDeserialize,
960    {
961        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
962            Ok(Box::<T>::deserialize_reader(reader)?.into())
963        }
964    }
965
966    /// This impl requires the [`"rc"`] Cargo feature of borsh.
967    ///
968    /// Deserializing a data structure containing `Arc` will not attempt to
969    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
970    /// will end up with a strong count of 1.
971    impl<T: ?Sized> BorshDeserialize for Arc<T>
972    where
973        Box<T>: BorshDeserialize,
974    {
975        fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
976            Ok(Box::<T>::deserialize_reader(reader)?.into())
977        }
978    }
979}
980
981impl<T: ?Sized> BorshDeserialize for PhantomData<T> {
982    fn deserialize_reader<R: Read>(_: &mut R) -> Result<Self> {
983        Ok(PhantomData)
984    }
985}
986
987impl<T> BorshDeserialize for core::cell::Cell<T>
988where
989    T: BorshDeserialize + Copy,
990{
991    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
992        <T as BorshDeserialize>::deserialize_reader(reader).map(core::cell::Cell::new)
993    }
994}
995
996impl<T> BorshDeserialize for core::cell::RefCell<T>
997where
998    T: BorshDeserialize,
999{
1000    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
1001        <T as BorshDeserialize>::deserialize_reader(reader).map(core::cell::RefCell::new)
1002    }
1003}
1004
1005/// Deserializes an object from a slice of bytes.
1006/// # Example
1007/// ```
1008/// use borsh::{BorshDeserialize, BorshSerialize, from_slice, to_vec};
1009///
1010/// /// derive is only available if borsh is built with `features = ["derive"]`
1011/// # #[cfg(feature = "derive")]
1012/// #[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
1013/// struct MyStruct {
1014///    a: u64,
1015///    b: Vec<u8>,
1016/// }
1017///
1018/// # #[cfg(feature = "derive")]
1019/// let original = MyStruct { a: 10, b: vec![1, 2, 3] };
1020/// # #[cfg(feature = "derive")]
1021/// let encoded = to_vec(&original).unwrap();
1022/// # #[cfg(feature = "derive")]
1023/// let decoded = from_slice::<MyStruct>(&encoded).unwrap();
1024/// # #[cfg(feature = "derive")]
1025/// assert_eq!(original, decoded);
1026/// ```
1027/// # Panics
1028/// If the data is invalid, this function will panic.
1029/// # Errors
1030/// If the data is invalid, this function will return an error.
1031/// # Note
1032/// This function will return an error if the data is not fully read.
1033pub fn from_slice<T: BorshDeserialize>(v: &[u8]) -> Result<T> {
1034    let mut v_mut = v;
1035    let object = T::deserialize(&mut v_mut)?;
1036    if !v_mut.is_empty() {
1037        return Err(Error::new(
1038            ErrorKind::InvalidData,
1039            crate::de::ERROR_NOT_ALL_BYTES_READ,
1040        ));
1041    }
1042    Ok(object)
1043}
1044
1045/// Deserializes an object from a reader.
1046/// # Example
1047/// ```
1048/// use borsh::{BorshDeserialize, BorshSerialize, from_reader, to_vec};
1049///
1050/// /// derive is only available if borsh is built with `features = ["derive"]`
1051/// # #[cfg(feature = "derive")]
1052/// #[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
1053/// struct MyStruct {
1054///     a: u64,
1055///     b: Vec<u8>,
1056/// }
1057///
1058/// # #[cfg(feature = "derive")]
1059/// let original = MyStruct { a: 10, b: vec![1, 2, 3] };
1060/// # #[cfg(feature = "derive")]
1061/// let encoded = to_vec(&original).unwrap();
1062/// # #[cfg(feature = "derive")]
1063/// let decoded = from_reader::<_, MyStruct>(&mut encoded.as_slice()).unwrap();
1064/// # #[cfg(feature = "derive")]
1065/// assert_eq!(original, decoded);
1066/// ```
1067pub fn from_reader<R: Read, T: BorshDeserialize>(reader: &mut R) -> Result<T> {
1068    let result = T::deserialize_reader(reader)?;
1069    let mut buf = [0u8; 1];
1070    match reader.read_exact(&mut buf) {
1071        Err(f) if f.kind() == ErrorKind::UnexpectedEof => Ok(result),
1072        _ => Err(Error::new(ErrorKind::InvalidData, ERROR_NOT_ALL_BYTES_READ)),
1073    }
1074}
borsh/de/mod.rs

borsh/de/
mod.rs
