darkfi_serial/
lib.rs

1/* This file is part of DarkFi (https://dark.fi)
2 *
3 * Copyright (C) 2020-2026 Dyne.org foundation
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU Affero General Public License as
7 * published by the Free Software Foundation, either version 3 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU Affero General Public License for more details.
14 *
15 * You should have received a copy of the GNU Affero General Public License
16 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
17 */
18
19use std::{
20    collections::VecDeque,
21    io::{Cursor, Error, Read, Write},
22};
23
24#[cfg(feature = "derive")]
25pub use darkfi_derive::{SerialDecodable, SerialEncodable};
26
27#[cfg(feature = "async")]
28mod async_lib;
29#[cfg(feature = "async")]
30pub use async_lib::{
31    async_trait, deserialize_async, deserialize_async_limited, deserialize_async_limited_partial,
32    deserialize_async_partial, serialize_async, AsyncDecodable, AsyncEncodable, AsyncRead,
33    AsyncReadExt, AsyncWrite, AsyncWriteExt, FutAsyncReadExt, FutAsyncWriteExt,
34};
35
36mod endian;
37mod types;
38
39/// Data which can be encoded in a consensus-consistent way.
40pub trait Encodable {
41    /// Encode an object with a well-defined format.
42    /// Should only ever error if the underlying `Write` errors.
43    /// Returns the number of bytes written on success.
44    fn encode<W: Write>(&self, e: &mut W) -> Result<usize, Error>;
45}
46
47/// Data which can be decoded in a consensus-consistent way.
48pub trait Decodable: Sized {
49    fn decode<D: Read>(d: &mut D) -> Result<Self, Error>;
50}
51
52/// Encode an object into a vector.
53pub fn serialize<T: Encodable + ?Sized>(data: &T) -> Vec<u8> {
54    let mut encoder = Vec::new();
55    let len = data.encode(&mut encoder).unwrap();
56    assert_eq!(len, encoder.len());
57    encoder
58}
59
60/// Deserialize a variable-length object from a vector, enforce a maximum
61/// size limit, but do not error if the entire vector is not consumed.
62///
63/// Expects objects with VarInt length encoding.
64pub fn deserialize_limited_partial<T: Decodable>(
65    data: &[u8],
66    max_len: usize,
67) -> Result<(T, usize), Error> {
68    let (len, _) = deserialize_partial::<VarInt>(data)?;
69    let obj_len = len.0 as usize;
70
71    if obj_len > max_len {
72        return Err(Error::other("Data size exceeds set `max_len`"))
73    }
74
75    deserialize_partial(data)
76}
77
78/// Deserialize an object from a vector, but do not error if the entire
79/// vector is not consumed.
80pub fn deserialize_partial<T: Decodable>(data: &[u8]) -> Result<(T, usize), Error> {
81    let mut decoder = Cursor::new(data);
82    let rv = Decodable::decode(&mut decoder)?;
83    let consumed = decoder.position() as usize;
84
85    Ok((rv, consumed))
86}
87
88/// Deserialize a variable-length object from a vector, but enforce a
89/// maximum size limit.
90///
91/// Expects objects with VarInt length encoding.
92pub fn deserialize_limited<T: Decodable>(data: &[u8], max_len: usize) -> Result<T, Error> {
93    let (len, _) = deserialize_partial::<VarInt>(data)?;
94    let obj_len = len.0 as usize;
95
96    if obj_len > max_len {
97        return Err(Error::other("Data size exceeds set `max_len`"))
98    }
99
100    deserialize(data)
101}
102
103/// Deserialize an object from a vector.
104/// Will error if said deserialization doesn't consume the entire vector.
105pub fn deserialize<T: Decodable>(data: &[u8]) -> Result<T, Error> {
106    let (rv, consumed) = deserialize_partial(data)?;
107
108    // Fail if data is not consumed entirely.
109    if consumed != data.len() {
110        return Err(Error::other("Data not consumed fully on deserialization"))
111    }
112
113    Ok(rv)
114}
115
116/// Extensions of `Write` to encode data as per Bitcoin consensus.
117pub trait WriteExt {
118    /// Output a 128-bit unsigned int
119    fn write_u128(&mut self, v: u128) -> Result<(), Error>;
120    /// Output a 64-bit unsigned int
121    fn write_u64(&mut self, v: u64) -> Result<(), Error>;
122    /// Output a 32-bit unsigned int
123    fn write_u32(&mut self, v: u32) -> Result<(), Error>;
124    /// Output a 16-bit unsigned int
125    fn write_u16(&mut self, v: u16) -> Result<(), Error>;
126    /// Output an 8-bit unsigned int
127    fn write_u8(&mut self, v: u8) -> Result<(), Error>;
128
129    /// Output a 128-bit signed int
130    fn write_i128(&mut self, v: i128) -> Result<(), Error>;
131    /// Output a 64-bit signed int
132    fn write_i64(&mut self, v: i64) -> Result<(), Error>;
133    /// Ouptut a 32-bit signed int
134    fn write_i32(&mut self, v: i32) -> Result<(), Error>;
135    /// Output a 16-bit signed int
136    fn write_i16(&mut self, v: i16) -> Result<(), Error>;
137    /// Output an 8-bit signed int
138    fn write_i8(&mut self, v: i8) -> Result<(), Error>;
139
140    /// Output a 64-bit floating point int
141    fn write_f64(&mut self, v: f64) -> Result<(), Error>;
142    /// Output a 32-bit floating point int
143    fn write_f32(&mut self, v: f32) -> Result<(), Error>;
144
145    /// Output a boolean
146    fn write_bool(&mut self, v: bool) -> Result<(), Error>;
147
148    /// Output a byte slice
149    fn write_slice(&mut self, v: &[u8]) -> Result<(), Error>;
150}
151
152/// Extensions of `Read` to decode data as per Bitcoin consensus.
153pub trait ReadExt {
154    /// Read a 128-bit unsigned int
155    fn read_u128(&mut self) -> Result<u128, Error>;
156    /// Read a 64-bit unsigned int
157    fn read_u64(&mut self) -> Result<u64, Error>;
158    /// Read a 32-bit unsigned int
159    fn read_u32(&mut self) -> Result<u32, Error>;
160    /// Read a 16-bit unsigned int
161    fn read_u16(&mut self) -> Result<u16, Error>;
162    /// Read an 8-bit unsigned int
163    fn read_u8(&mut self) -> Result<u8, Error>;
164
165    /// Read a 128-bit signed int
166    fn read_i128(&mut self) -> Result<i128, Error>;
167    /// Read a 64-bit signed int
168    fn read_i64(&mut self) -> Result<i64, Error>;
169    /// Ouptut a 32-bit signed int
170    fn read_i32(&mut self) -> Result<i32, Error>;
171    /// Read a 16-bit signed int
172    fn read_i16(&mut self) -> Result<i16, Error>;
173    /// Read an 8-bit signed int
174    fn read_i8(&mut self) -> Result<i8, Error>;
175
176    /// Read a 64-bit floating point int
177    fn read_f64(&mut self) -> Result<f64, Error>;
178    /// Read a 32-bit floating point int
179    fn read_f32(&mut self) -> Result<f32, Error>;
180
181    /// Read a boolean
182    fn read_bool(&mut self) -> Result<bool, Error>;
183
184    /// Read a byte slice
185    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), Error>;
186}
187
188macro_rules! encoder_fn {
189    ($name:ident, $val_type:ty, $writefn:ident) => {
190        #[inline]
191        fn $name(&mut self, v: $val_type) -> Result<(), Error> {
192            self.write_all(&endian::$writefn(v))
193        }
194    };
195}
196
197macro_rules! decoder_fn {
198    ($name:ident, $val_type:ty, $readfn:ident, $byte_len:expr) => {
199        #[inline]
200        fn $name(&mut self) -> Result<$val_type, Error> {
201            assert_eq!(core::mem::size_of::<$val_type>(), $byte_len);
202            let mut val = [0; $byte_len];
203            self.read_exact(&mut val[..])?;
204            Ok(endian::$readfn(&val))
205        }
206    };
207}
208
209impl<W: Write> WriteExt for W {
210    encoder_fn!(write_u128, u128, u128_to_array_le);
211    encoder_fn!(write_u64, u64, u64_to_array_le);
212    encoder_fn!(write_u32, u32, u32_to_array_le);
213    encoder_fn!(write_u16, u16, u16_to_array_le);
214    encoder_fn!(write_i128, i128, i128_to_array_le);
215    encoder_fn!(write_i64, i64, i64_to_array_le);
216    encoder_fn!(write_i32, i32, i32_to_array_le);
217    encoder_fn!(write_i16, i16, i16_to_array_le);
218    encoder_fn!(write_f64, f64, f64_to_array_le);
219    encoder_fn!(write_f32, f32, f32_to_array_le);
220
221    #[inline]
222    fn write_i8(&mut self, v: i8) -> Result<(), Error> {
223        self.write_all(&[v as u8])
224    }
225    #[inline]
226    fn write_u8(&mut self, v: u8) -> Result<(), Error> {
227        self.write_all(&[v])
228    }
229    #[inline]
230    fn write_bool(&mut self, v: bool) -> Result<(), Error> {
231        self.write_all(&[v as u8])
232    }
233    #[inline]
234    fn write_slice(&mut self, v: &[u8]) -> Result<(), Error> {
235        self.write_all(v)
236    }
237}
238
239impl<R: Read> ReadExt for R {
240    decoder_fn!(read_u128, u128, slice_to_u128_le, 16);
241    decoder_fn!(read_u64, u64, slice_to_u64_le, 8);
242    decoder_fn!(read_u32, u32, slice_to_u32_le, 4);
243    decoder_fn!(read_u16, u16, slice_to_u16_le, 2);
244    decoder_fn!(read_i128, i128, slice_to_i128_le, 16);
245    decoder_fn!(read_i64, i64, slice_to_i64_le, 8);
246    decoder_fn!(read_i32, i32, slice_to_i32_le, 4);
247    decoder_fn!(read_i16, i16, slice_to_i16_le, 2);
248    decoder_fn!(read_f64, f64, slice_to_f64_le, 8);
249    decoder_fn!(read_f32, f32, slice_to_f32_le, 4);
250
251    #[inline]
252    fn read_u8(&mut self) -> Result<u8, Error> {
253        let mut slice = [0u8; 1];
254        self.read_exact(&mut slice)?;
255        Ok(slice[0])
256    }
257    #[inline]
258    fn read_i8(&mut self) -> Result<i8, Error> {
259        let mut slice = [0u8; 1];
260        self.read_exact(&mut slice)?;
261        Ok(slice[0] as i8)
262    }
263    #[inline]
264    fn read_bool(&mut self) -> Result<bool, Error> {
265        ReadExt::read_i8(self).map(|bit| bit != 0)
266    }
267    #[inline]
268    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), Error> {
269        self.read_exact(slice)
270    }
271}
272
273macro_rules! impl_int_encodable {
274    ($ty:ident, $meth_dec:ident, $meth_enc:ident) => {
275        impl Decodable for $ty {
276            #[inline]
277            fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
278                ReadExt::$meth_dec(d).map($ty::from_le)
279            }
280        }
281
282        impl Encodable for $ty {
283            #[inline]
284            fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
285                s.$meth_enc(self.to_le())?;
286                Ok(core::mem::size_of::<$ty>())
287            }
288        }
289    };
290}
291
292impl_int_encodable!(u8, read_u8, write_u8);
293impl_int_encodable!(u16, read_u16, write_u16);
294impl_int_encodable!(u32, read_u32, write_u32);
295impl_int_encodable!(u64, read_u64, write_u64);
296impl_int_encodable!(u128, read_u128, write_u128);
297
298impl_int_encodable!(i8, read_i8, write_i8);
299impl_int_encodable!(i16, read_i16, write_i16);
300impl_int_encodable!(i32, read_i32, write_i32);
301impl_int_encodable!(i64, read_i64, write_i64);
302impl_int_encodable!(i128, read_i128, write_i128);
303
304/// Variable-integer encoding.
305///
306/// Integer can be encoded depending on the represented value to save space.
307/// Variable length integers always precede an array/vector of a type of data
308/// that may vary in length. Longer numbers are encoded in little endian.
309///
310/// | Value         | Storage length | Format                              |
311/// |---------------|----------------|-------------------------------------|
312/// | <= 0xfc       | 1              | u8                                  |
313/// | <= 0xffff     | 3              | `0xfd` followed by `value` as `u16` |
314/// | <= 0xffffffff | 5              | `0xfe` followed by `value` as `u32` |
315/// | -             | 9              | `0xff` followed by `value` as `u64` |
316///
317/// See also [Bitcoin variable length integers](https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer).
318#[derive(Debug, PartialEq, Eq)]
319pub struct VarInt(pub u64);
320
321impl VarInt {
322    /// Gets the length of this `VarInt` when encoded.
323    /// Returns:
324    /// * 1 for 0..0xFC
325    /// * 3 for 0xFD..(2^16-1)
326    /// * 5 for 0x10000..(2^32-1)
327    /// * 9 otherwise
328    #[inline]
329    pub fn length(&self) -> usize {
330        match self.0 {
331            0..=0xFC => 1,
332            0xFD..=0xFFFF => 3,
333            0x10000..=0xFFFFFFFF => 5,
334            _ => 9,
335        }
336    }
337}
338
339impl Encodable for VarInt {
340    #[inline]
341    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
342        match self.0 {
343            0..=0xFC => {
344                (self.0 as u8).encode(s)?;
345                Ok(1)
346            }
347
348            0xFD..=0xFFFF => {
349                s.write_u8(0xFD)?;
350                (self.0 as u16).encode(s)?;
351                Ok(3)
352            }
353
354            0x10000..=0xFFFFFFFF => {
355                s.write_u8(0xFE)?;
356                (self.0 as u32).encode(s)?;
357                Ok(5)
358            }
359
360            _ => {
361                s.write_u8(0xFF)?;
362                self.0.encode(s)?;
363                Ok(9)
364            }
365        }
366    }
367}
368
369impl Decodable for VarInt {
370    #[inline]
371    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
372        let n = ReadExt::read_u8(d)?;
373        match n {
374            0xFF => {
375                let x = ReadExt::read_u64(d)?;
376                if x < 0x100000000 {
377                    return Err(Error::other("Non-minimal VarInt"))
378                }
379                Ok(VarInt(x))
380            }
381
382            0xFE => {
383                let x = ReadExt::read_u32(d)?;
384                if x < 0x10000 {
385                    return Err(Error::other("Non-minimal VarInt"))
386                }
387                Ok(VarInt(x as u64))
388            }
389
390            0xFD => {
391                let x = ReadExt::read_u16(d)?;
392                if x < 0xFD {
393                    return Err(Error::other("Non-minimal VarInt"))
394                }
395                Ok(VarInt(x as u64))
396            }
397
398            n => Ok(VarInt(n as u64)),
399        }
400    }
401}
402
403macro_rules! tuple_encode {
404    ($($x:ident),*) => (
405        impl<$($x: Encodable),*> Encodable for ($($x),*) {
406            #[inline]
407            #[allow(non_snake_case)]
408            fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
409                let &($(ref $x),*) = self;
410                let mut len = 0;
411                $(len += $x.encode(s)?;)*
412                Ok(len)
413            }
414        }
415
416        impl<$($x: Decodable),*> Decodable for ($($x),*) {
417            #[inline]
418            #[allow(non_snake_case)]
419            fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
420                Ok(($({let $x = Decodable::decode(d)?; $x }),*))
421            }
422        }
423    )
424}
425
426tuple_encode!(T0, T1);
427tuple_encode!(T0, T1, T2);
428tuple_encode!(T0, T1, T2, T3);
429tuple_encode!(T0, T1, T2, T3, T4);
430tuple_encode!(T0, T1, T2, T3, T4, T5);
431tuple_encode!(T0, T1, T2, T3, T4, T5, T6);
432tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
433
434/// Encode a dynamic set of arguments to a buffer.
435#[macro_export]
436macro_rules! encode_payload {
437    ($buf:expr, $($args:expr),*) => {{ $( $args.encode($buf)?;)* }}
438}
439
440// Implementations for some primitive types.
441impl Encodable for usize {
442    #[inline]
443    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
444        s.write_u64(*self as u64)?;
445        Ok(8)
446    }
447}
448
449impl Decodable for usize {
450    #[inline]
451    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
452        Ok(ReadExt::read_u64(d)? as usize)
453    }
454}
455
456impl Encodable for f64 {
457    #[inline]
458    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
459        s.write_f64(*self)?;
460        Ok(core::mem::size_of::<f64>())
461    }
462}
463
464impl Decodable for f64 {
465    #[inline]
466    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
467        ReadExt::read_f64(d)
468    }
469}
470
471impl Encodable for f32 {
472    #[inline]
473    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
474        s.write_f32(*self)?;
475        Ok(core::mem::size_of::<f32>())
476    }
477}
478
479impl Decodable for f32 {
480    #[inline]
481    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
482        ReadExt::read_f32(d)
483    }
484}
485
486impl Encodable for bool {
487    #[inline]
488    fn encode<S: WriteExt>(&self, s: &mut S) -> Result<usize, Error> {
489        s.write_bool(*self)?;
490        Ok(1)
491    }
492}
493
494impl Decodable for bool {
495    #[inline]
496    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
497        ReadExt::read_bool(d)
498    }
499}
500
501impl<T: Encodable> Encodable for Vec<T> {
502    #[inline]
503    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
504        let mut len = 0;
505        len += VarInt(self.len() as u64).encode(s)?;
506        for val in self {
507            len += val.encode(s)?;
508        }
509        Ok(len)
510    }
511}
512
513impl<T: Encodable> Encodable for &[T] {
514    #[inline]
515    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
516        let mut len = 0;
517        len += VarInt(self.len() as u64).encode(s)?;
518        for val in self.iter() {
519            len += val.encode(s)?;
520        }
521        Ok(len)
522    }
523}
524
525impl<T: Decodable> Decodable for Vec<T> {
526    #[inline]
527    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
528        let len = VarInt::decode(d)?.0;
529        let mut ret = Vec::new();
530        ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
531        for _ in 0..len {
532            ret.push(Decodable::decode(d)?);
533        }
534        Ok(ret)
535    }
536}
537
538impl<T: Encodable> Encodable for VecDeque<T> {
539    #[inline]
540    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
541        let mut len = 0;
542        len += VarInt(self.len() as u64).encode(s)?;
543        for val in self {
544            len += val.encode(s)?;
545        }
546        Ok(len)
547    }
548}
549
550impl<T: Decodable> Decodable for VecDeque<T> {
551    #[inline]
552    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
553        let len = VarInt::decode(d)?.0;
554        let mut ret = VecDeque::new();
555        ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
556        for _ in 0..len {
557            ret.push_back(Decodable::decode(d)?);
558        }
559        Ok(ret)
560    }
561}
562
563impl<T: Encodable> Encodable for Option<T> {
564    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
565        let mut len = 0;
566        if let Some(v) = self {
567            len += true.encode(s)?;
568            len += v.encode(s)?;
569        } else {
570            len += false.encode(s)?;
571        }
572        Ok(len)
573    }
574}
575
576impl<T: Decodable> Decodable for Option<T> {
577    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
578        let valid: bool = Decodable::decode(d)?;
579        let val = if valid { Some(Decodable::decode(d)?) } else { None };
580        Ok(val)
581    }
582}
583
584impl<T, const N: usize> Encodable for [T; N]
585where
586    T: Encodable,
587{
588    #[inline]
589    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
590        let mut len = 0;
591        for elem in self.iter() {
592            len += elem.encode(s)?;
593        }
594        Ok(len)
595    }
596}
597
598impl<T, const N: usize> Decodable for [T; N]
599where
600    T: Decodable + core::fmt::Debug,
601{
602    #[inline]
603    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
604        let mut ret = vec![];
605        for _ in 0..N {
606            ret.push(Decodable::decode(d)?);
607        }
608
609        Ok(ret.try_into().unwrap())
610    }
611}
612
613impl Encodable for String {
614    #[inline]
615    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
616        let b = self.as_bytes();
617        let b_len = b.len();
618        let vi_len = VarInt(b_len as u64).encode(s)?;
619        s.write_slice(b)?;
620        Ok(vi_len + b_len)
621    }
622}
623
624impl Encodable for &str {
625    #[inline]
626    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
627        let b = self.as_bytes();
628        let b_len = b.len();
629        let vi_len = VarInt(b_len as u64).encode(s)?;
630        s.write_slice(b)?;
631        Ok(vi_len + b_len)
632    }
633}
634
635impl Decodable for String {
636    #[inline]
637    fn decode<D: Read>(d: &mut D) -> Result<String, Error> {
638        match String::from_utf8(Decodable::decode(d)?) {
639            Ok(v) => Ok(v),
640            Err(_) => Err(Error::other("Invalid UTF-8 for string")),
641        }
642    }
643}
644
645/*
646impl Encodable for Cow<'static, str> {
647    #[inline]
648    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
649        let b = self.as_bytes();
650        let b_len = b.len();
651        let vi_len = VarInt(b_len as u64).encode(&mut s)?;
652        s.write_slice(b)?;
653        Ok(vi_len + b_len)
654    }
655}
656
657impl Decodable for Cow<'static, str> {
658    #[inline]
659    fn decode<D: Read>(d: D) -> Result<Cow<'static, str>, Error> {
660        match String::from_utf8(Decodable::decode(d)?) {
661            Ok(v) => v.map(Cow::Owned),
662            Err(_) => Err(Error::other("Invalid UTF-8 for string")),
663        }
664    }
665}
666*/
667
668#[cfg(test)]
669mod tests {
670    use super::{endian::*, *};
671    use futures_lite::AsyncWriteExt;
672
673    #[test]
674    fn serialize_int_test() {
675        // bool
676        assert_eq!(serialize(&false), vec![0u8]);
677        assert_eq!(serialize(&true), vec![1u8]);
678        // u8
679        assert_eq!(serialize(&1u8), vec![1u8]);
680        assert_eq!(serialize(&0u8), vec![0u8]);
681        assert_eq!(serialize(&255u8), vec![255u8]);
682        // u16
683        assert_eq!(serialize(&1u16), vec![1u8, 0]);
684        assert_eq!(serialize(&256u16), vec![0u8, 1]);
685        assert_eq!(serialize(&5000u16), vec![136u8, 19]);
686        // u32
687        assert_eq!(serialize(&1u32), vec![1u8, 0, 0, 0]);
688        assert_eq!(serialize(&256u32), vec![0u8, 1, 0, 0]);
689        assert_eq!(serialize(&5000u32), vec![136u8, 19, 0, 0]);
690        assert_eq!(serialize(&500000u32), vec![32u8, 161, 7, 0]);
691        assert_eq!(serialize(&168430090u32), vec![10u8, 10, 10, 10]);
692        // i32
693        assert_eq!(serialize(&-1i32), vec![255u8, 255, 255, 255]);
694        assert_eq!(serialize(&-256i32), vec![0u8, 255, 255, 255]);
695        assert_eq!(serialize(&-5000i32), vec![120u8, 236, 255, 255]);
696        assert_eq!(serialize(&-500000i32), vec![224u8, 94, 248, 255]);
697        assert_eq!(serialize(&-168430090i32), vec![246u8, 245, 245, 245]);
698        assert_eq!(serialize(&1i32), vec![1u8, 0, 0, 0]);
699        assert_eq!(serialize(&256i32), vec![0u8, 1, 0, 0]);
700        assert_eq!(serialize(&5000i32), vec![136u8, 19, 0, 0]);
701        assert_eq!(serialize(&500000i32), vec![32u8, 161, 7, 0]);
702        assert_eq!(serialize(&168430090i32), vec![10u8, 10, 10, 10]);
703        // u64
704        assert_eq!(serialize(&1u64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
705        assert_eq!(serialize(&256u64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
706        assert_eq!(serialize(&5000u64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
707        assert_eq!(serialize(&500000u64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
708        assert_eq!(serialize(&723401728380766730u64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
709        // i64
710        assert_eq!(serialize(&-1i64), vec![255u8, 255, 255, 255, 255, 255, 255, 255]);
711        assert_eq!(serialize(&-256i64), vec![0u8, 255, 255, 255, 255, 255, 255, 255]);
712        assert_eq!(serialize(&-5000i64), vec![120u8, 236, 255, 255, 255, 255, 255, 255]);
713        assert_eq!(serialize(&-500000i64), vec![224u8, 94, 248, 255, 255, 255, 255, 255]);
714        assert_eq!(
715            serialize(&-723401728380766730i64),
716            vec![246u8, 245, 245, 245, 245, 245, 245, 245]
717        );
718        assert_eq!(serialize(&1i64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
719        assert_eq!(serialize(&256i64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
720        assert_eq!(serialize(&5000i64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
721        assert_eq!(serialize(&500000i64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
722        assert_eq!(serialize(&723401728380766730i64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
723    }
724
725    #[test]
726    fn serialize_float_test() {
727        // f64
728        assert_eq!(serialize(&1.5f64), vec![0u8, 0, 0, 0, 0, 0, 248, 63]);
729        assert_eq!(serialize(&256.7f64), vec![51u8, 51, 51, 51, 51, 11, 112, 64]);
730        assert_eq!(serialize(&5000.21f64), vec![41u8, 92, 143, 194, 53, 136, 179, 64]);
731        assert_eq!(serialize(&500000.314f64), vec![76u8, 55, 137, 65, 129, 132, 30, 65]);
732        assert_eq!(serialize(&1102021.1102021f64), vec![111u8, 52, 54, 28, 197, 208, 48, 65]);
733        assert_eq!(
734            serialize(&723401728380766730.894612f64),
735            vec![20u8, 20, 20, 20, 20, 20, 164, 67]
736        );
737        assert_eq!(serialize(&-1.5f64), vec![0u8, 0, 0, 0, 0, 0, 248, 191]);
738        assert_eq!(serialize(&-256.7f64), vec![51u8, 51, 51, 51, 51, 11, 112, 192]);
739        assert_eq!(serialize(&-5000.21f64), vec![41u8, 92, 143, 194, 53, 136, 179, 192]);
740        assert_eq!(serialize(&-500000.314f64), vec![76u8, 55, 137, 65, 129, 132, 30, 193]);
741        assert_eq!(serialize(&-1102021.1102021f64), vec![111u8, 52, 54, 28, 197, 208, 48, 193]);
742        assert_eq!(
743            serialize(&-723401728380766730.894612f64),
744            vec![20u8, 20, 20, 20, 20, 20, 164, 195]
745        );
746        // f32
747        assert_eq!(serialize(&1.5f32), vec![0u8, 0, 192, 63]);
748        assert_eq!(serialize(&256.7f32), vec![154u8, 89, 128, 67]);
749        assert_eq!(serialize(&5000.21f32), vec![174u8, 65, 156, 69]);
750        assert_eq!(serialize(&500000.3f32), vec![10u8, 36, 244, 72]);
751        assert_eq!(serialize(&1102021.1f32), vec![41u8, 134, 134, 73]);
752        assert_eq!(serialize(&72340172838076673.9f32), vec![129u8, 128, 128, 91]);
753        assert_eq!(serialize(&-1.5f32), vec![0u8, 0, 192, 191]);
754        assert_eq!(serialize(&-256.7f32), vec![154u8, 89, 128, 195]);
755        assert_eq!(serialize(&-5000.21f32), vec![174u8, 65, 156, 197]);
756        assert_eq!(serialize(&-500000.3f32), vec![10u8, 36, 244, 200]);
757        assert_eq!(serialize(&-1102021.1f32), vec![41u8, 134, 134, 201]);
758        assert_eq!(serialize(&-72340172838076673.9f32), vec![129u8, 128, 128, 219]);
759    }
760
761    #[test]
762    fn serialize_varint_test() {
763        assert_eq!(serialize(&VarInt(10)), vec![10u8]);
764        assert_eq!(serialize(&VarInt(0xFC)), vec![0xFCu8]);
765        assert_eq!(serialize(&VarInt(0xFD)), vec![0xFDu8, 0xFD, 0]);
766        assert_eq!(serialize(&VarInt(0xFFF)), vec![0xFDu8, 0xFF, 0xF]);
767        assert_eq!(serialize(&VarInt(0xF0F0F0F)), vec![0xFEu8, 0xF, 0xF, 0xF, 0xF]);
768        assert_eq!(
769            serialize(&VarInt(0xF0F0F0F0F0E0)),
770            vec![0xFFu8, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0, 0]
771        );
772        assert_eq!(
773            test_varint_encode(0xFF, &u64_to_array_le(0x100000000)).unwrap(),
774            VarInt(0x100000000)
775        );
776        assert_eq!(test_varint_encode(0xFE, &u64_to_array_le(0x10000)).unwrap(), VarInt(0x10000));
777        assert_eq!(test_varint_encode(0xFD, &u64_to_array_le(0xFD)).unwrap(), VarInt(0xFD));
778
779        // Test that length calc is working correctly
780        test_varint_len(VarInt(0), 1);
781        test_varint_len(VarInt(0xFC), 1);
782        test_varint_len(VarInt(0xFD), 3);
783        test_varint_len(VarInt(0xFFFF), 3);
784        test_varint_len(VarInt(0x10000), 5);
785        test_varint_len(VarInt(0xFFFFFFFF), 5);
786        test_varint_len(VarInt(0xFFFFFFFF + 1), 9);
787        test_varint_len(VarInt(u64::MAX), 9);
788    }
789
790    fn test_varint_len(varint: VarInt, expected: usize) {
791        let mut encoder = Cursor::new(vec![]);
792        assert_eq!(varint.encode(&mut encoder).unwrap(), expected);
793        assert_eq!(varint.length(), expected);
794    }
795
796    fn test_varint_encode(n: u8, x: &[u8]) -> Result<VarInt, Error> {
797        let mut input = [0u8; 9];
798        input[0] = n;
799        input[1..x.len() + 1].copy_from_slice(x);
800        deserialize_partial::<VarInt>(&input).map(|t| t.0)
801    }
802
803    #[test]
804    fn deserialize_nonminimal_vec() {
805        // Check the edges for variant int
806        assert!(test_varint_encode(0xFF, &u64_to_array_le(0x100000000 - 1)).is_err());
807        assert!(test_varint_encode(0xFE, &u32_to_array_le(0x10000 - 1)).is_err());
808        assert!(test_varint_encode(0xFD, &u16_to_array_le(0xFD - 1)).is_err());
809        assert!(deserialize::<Vec<u8>>(&[0xfd, 0x00, 0x00]).is_err());
810        assert!(deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).is_err());
811        assert!(deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).is_err());
812        assert!(deserialize::<Vec<u8>>(&[0xfe, 0xff, 0x00, 0x00, 0x00]).is_err());
813        assert!(deserialize::<Vec<u8>>(&[0xfe, 0xff, 0xff, 0x00, 0x00]).is_err());
814        assert!(deserialize::<Vec<u8>>(&[0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
815            .is_err());
816        assert!(deserialize::<Vec<u8>>(&[0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00])
817            .is_err());
818
819        let mut vec_256 = vec![0; 259];
820        vec_256[0] = 0xfd;
821        vec_256[1] = 0x00;
822        vec_256[2] = 0x01;
823        assert!(deserialize::<Vec<u8>>(&vec_256).is_ok());
824
825        let mut vec_253 = vec![0; 256];
826        vec_253[0] = 0xfd;
827        vec_253[1] = 0xfd;
828        vec_253[2] = 0x00;
829        assert!(deserialize::<Vec<u8>>(&vec_253).is_ok());
830    }
831
832    #[test]
833    fn serialize_vector_test() {
834        assert_eq!(serialize(&vec![1u8, 2, 3]), vec![3u8, 1, 2, 3]);
835        assert_eq!(serialize(&vec![1u16, 2u16]), vec![2u8, 1, 0, 2, 0]);
836        assert_eq!(serialize(&vec![256u16, 5000u16]), vec![2u8, 0, 1, 136, 19]);
837        assert_eq!(
838            serialize(&vec![1u32, 256u32, 5000u32]),
839            vec![3u8, 1, 0, 0, 0, 0, 1, 0, 0, 136, 19, 0, 0]
840        );
841        assert_eq!(
842            serialize(&vec![1u64, 256u64, 5000u64, 500000u64]),
843            vec![
844                4u8, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 136, 19, 0, 0, 0, 0, 0, 0, 32,
845                161, 7, 0, 0, 0, 0, 0
846            ]
847        );
848        assert_eq!(serialize(&vec![-1i8]), vec![1u8, 255]);
849        assert_eq!(serialize(&vec![1i8, -2i8, -3i8]), vec![3u8, 1, 254, 253]);
850        assert_eq!(serialize(&vec![-1i32]), vec![1u8, 255, 255, 255, 255]);
851        assert_eq!(serialize(&vec![-1i32, -256]), vec![2u8, 255, 255, 255, 255, 0, 255, 255, 255]);
852        assert_eq!(
853            serialize(&vec![-1i32, -2i32, -3i32]),
854            vec![3u8, 255, 255, 255, 255, 254, 255, 255, 255, 253, 255, 255, 255]
855        );
856        assert_eq!(
857            serialize(&vec![-1i64, -256i64, -5000i64, -500000i64]),
858            vec![
859                4u8, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255,
860                120, 236, 255, 255, 255, 255, 255, 255, 224, 94, 248, 255, 255, 255, 255, 255
861            ]
862        );
863    }
864
865    #[test]
866    fn serialize_strbuf_test() {
867        assert_eq!(serialize(&"Andrew".to_string()), vec![6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]);
868    }
869
870    #[test]
871    fn deserialize_int_test() {
872        // bool
873        assert!((deserialize(&[58u8, 0]) as Result<bool, Error>).is_err());
874        assert_eq!(deserialize(&[58u8]).ok(), Some(true));
875        assert_eq!(deserialize(&[1u8]).ok(), Some(true));
876        assert_eq!(deserialize(&[0u8]).ok(), Some(false));
877        assert!((deserialize(&[0u8, 1]) as Result<bool, Error>).is_err());
878
879        // u8
880        assert_eq!(deserialize(&[58u8]).ok(), Some(58u8));
881
882        // u16
883        assert_eq!(deserialize(&[0x01u8, 0x02]).ok(), Some(0x0201u16));
884        assert_eq!(deserialize(&[0xABu8, 0xCD]).ok(), Some(0xCDABu16));
885        assert_eq!(deserialize(&[0xA0u8, 0x0D]).ok(), Some(0xDA0u16));
886        let failure16: Result<u16, Error> = deserialize(&[1u8]);
887        assert!(failure16.is_err());
888
889        // u32
890        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABu32));
891        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD]).ok(), Some(0xCDAB0DA0u32));
892        let failure32: Result<u32, Error> = deserialize(&[1u8, 2, 3]);
893        assert!(failure32.is_err());
894
895        assert_eq!(deserialize(&[0x78u8, 0xec, 0xff, 0xff]).ok(), Some(-5000i32));
896        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABi32));
897        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0x2D]).ok(), Some(0x2DAB0DA0i32));
898        let failurei32: Result<i32, Error> = deserialize(&[1u8, 2, 3]);
899        assert!(failurei32.is_err());
900
901        // u64
902        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABu64));
903        assert_eq!(
904            deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
905            Some(0x99000099CDAB0DA0u64)
906        );
907        let failure64: Result<u64, Error> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
908        assert!(failure64.is_err());
909        assert_eq!(
910            deserialize(&[0xe0, 0x5e, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff]).ok(),
911            Some(-500000i64)
912        );
913        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABi64));
914        assert_eq!(
915            deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
916            Some(-0x66ffff663254f260i64)
917        );
918        let failurei64: Result<i64, Error> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
919        assert!(failurei64.is_err());
920    }
921    #[test]
922    fn deserialize_vec_test() {
923        assert_eq!(deserialize(&[3u8, 2, 3, 4]).ok(), Some(vec![2u8, 3, 4]));
924        assert!((deserialize(&[4u8, 2, 3, 4, 5, 6]) as Result<Vec<u8>, Error>).is_err());
925    }
926
927    #[test]
928    fn deserialize_strbuf_test() {
929        assert_eq!(
930            deserialize(&[6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]).ok(),
931            Some("Andrew".to_string())
932        );
933    }
934
935    #[test]
936    fn encode_payload_test() -> Result<(), Error> {
937        let mut i32_buf1 = vec![];
938        let mut i32_buf2 = vec![];
939        1_i32.encode(&mut i32_buf1)?;
940        2_i32.encode(&mut i32_buf2)?;
941
942        let mut string_buf = vec![];
943        b"Hello World".encode(&mut string_buf)?;
944
945        /*
946        eprintln!("{:?}", i32_buf1);
947        eprintln!("{:?}", i32_buf2);
948        eprintln!("{:?}", string_buf);
949        */
950
951        let mut buf = vec![];
952        let mut buf_verify = vec![];
953        buf_verify.extend_from_slice(&i32_buf1);
954        buf_verify.extend_from_slice(&i32_buf2);
955        buf_verify.extend_from_slice(&string_buf);
956
957        encode_payload!(&mut buf, 1_i32, 2_i32, b"Hello World");
958        assert_eq!(buf, buf_verify);
959
960        let mut f64_buf = vec![];
961        let mut i64_buf = vec![];
962        let mut bool_buf = vec![];
963        let mut u32_buf = vec![];
964        let mut array_buf = vec![];
965        1.5f64.encode(&mut f64_buf)?;
966        (-1i64).encode(&mut i64_buf)?;
967        true.encode(&mut bool_buf)?;
968        0x10000_u32.encode(&mut u32_buf)?;
969        [0xfe, 0xff, 0x00, 0x00, 0x00].encode(&mut array_buf)?;
970
971        /*
972        eprintln!("{:?}", f64_buf);
973        eprintln!("{:?}", i64_buf);
974        eprintln!("{:?}", bool_buf);
975        eprintln!("{:?}", u32_buf);
976        eprintln!("{:?}", array_buf);
977        */
978
979        let mut buf = vec![];
980        let mut buf_verify = vec![];
981        buf_verify.extend_from_slice(&f64_buf);
982        buf_verify.extend_from_slice(&i64_buf);
983        buf_verify.extend_from_slice(&bool_buf);
984        buf_verify.extend_from_slice(&u32_buf);
985        buf_verify.extend_from_slice(&array_buf);
986        encode_payload!(&mut buf, 1.5f64, -1i64, true, 0x10000_u32, [0xfe, 0xff, 0x00, 0x00, 0x00]);
987        assert_eq!(buf, buf_verify);
988
989        Ok(())
990    }
991
992    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
993    enum TestEnum0 {
994        First,
995        Second,
996        Third,
997    }
998
999    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
1000    enum TestEnum1 {
1001        First = 0x01,
1002        Second = 0x03,
1003        Third = 0xf1,
1004        Fourth = 0xfe,
1005    }
1006
1007    #[test]
1008    fn derive_serialize_deserialize_enum() {
1009        let first = serialize(&TestEnum0::First);
1010        let second = serialize(&TestEnum0::Second);
1011        let third = serialize(&TestEnum0::Third);
1012        assert_eq!(deserialize::<TestEnum0>(&first).unwrap(), TestEnum0::First);
1013        assert_eq!(deserialize::<TestEnum0>(&second).unwrap(), TestEnum0::Second);
1014        assert_eq!(deserialize::<TestEnum0>(&third).unwrap(), TestEnum0::Third);
1015
1016        let first = serialize(&TestEnum1::First);
1017        let second = serialize(&TestEnum1::Second);
1018        let third = serialize(&TestEnum1::Third);
1019        let fourth = serialize(&TestEnum1::Fourth);
1020        assert_eq!(first, [0x01]);
1021        assert_eq!(second, [0x03]);
1022        assert_eq!(third, [0xf1]);
1023        assert_eq!(fourth, [0xfe]);
1024    }
1025
1026    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
1027    struct TestStruct0 {
1028        foo: u64,
1029        bar: bool,
1030        baz: String,
1031    }
1032
1033    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
1034    struct TestStruct1(String);
1035
1036    #[test]
1037    fn derive_serialize_deserialize_struct() {
1038        let foo = 44;
1039        let bar = true;
1040        let baz = String::from("foobarbaz");
1041        let ts0 = TestStruct0 { foo, bar, baz: baz.clone() };
1042        let ts0_s = serialize(&ts0);
1043        let ts0_n = deserialize::<TestStruct0>(&ts0_s).unwrap();
1044        assert_eq!(foo, ts0_n.foo);
1045        assert_eq!(bar, ts0_n.bar);
1046        assert_eq!(baz, ts0_n.baz);
1047        assert_eq!(ts0, ts0_n);
1048        assert_eq!(ts0_n, TestStruct0 { foo, bar, baz: baz.clone() });
1049
1050        let ts1 = TestStruct1(baz.clone());
1051        let ts1_s = serialize(&ts1);
1052        let ts1_n = deserialize::<TestStruct1>(&ts1_s).unwrap();
1053        assert_eq!(ts1, ts1_n);
1054        assert_eq!(ts1_n, TestStruct1(baz));
1055    }
1056}
darkfi_serial/lib.rs

darkfi_serial/
lib.rs
