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: Decodable> Decodable for Vec<T> {
514    #[inline]
515    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
516        let len = VarInt::decode(d)?.0;
517        let mut ret = Vec::new();
518        ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
519        for _ in 0..len {
520            ret.push(Decodable::decode(d)?);
521        }
522        Ok(ret)
523    }
524}
525
526impl<T: Encodable> Encodable for VecDeque<T> {
527    #[inline]
528    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
529        let mut len = 0;
530        len += VarInt(self.len() as u64).encode(s)?;
531        for val in self {
532            len += val.encode(s)?;
533        }
534        Ok(len)
535    }
536}
537
538impl<T: Decodable> Decodable for VecDeque<T> {
539    #[inline]
540    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
541        let len = VarInt::decode(d)?.0;
542        let mut ret = VecDeque::new();
543        ret.try_reserve(len as usize).map_err(|_| std::io::ErrorKind::InvalidData)?;
544        for _ in 0..len {
545            ret.push_back(Decodable::decode(d)?);
546        }
547        Ok(ret)
548    }
549}
550
551impl<T: Encodable> Encodable for Option<T> {
552    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
553        let mut len = 0;
554        if let Some(v) = self {
555            len += true.encode(s)?;
556            len += v.encode(s)?;
557        } else {
558            len += false.encode(s)?;
559        }
560        Ok(len)
561    }
562}
563
564impl<T: Decodable> Decodable for Option<T> {
565    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
566        let valid: bool = Decodable::decode(d)?;
567        let val = if valid { Some(Decodable::decode(d)?) } else { None };
568        Ok(val)
569    }
570}
571
572impl<T, const N: usize> Encodable for [T; N]
573where
574    T: Encodable,
575{
576    #[inline]
577    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
578        let mut len = 0;
579        for elem in self.iter() {
580            len += elem.encode(s)?;
581        }
582        Ok(len)
583    }
584}
585
586impl<T, const N: usize> Decodable for [T; N]
587where
588    T: Decodable + core::fmt::Debug,
589{
590    #[inline]
591    fn decode<D: Read>(d: &mut D) -> Result<Self, Error> {
592        let mut ret = vec![];
593        for _ in 0..N {
594            ret.push(Decodable::decode(d)?);
595        }
596
597        Ok(ret.try_into().unwrap())
598    }
599}
600
601impl Encodable for String {
602    #[inline]
603    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
604        let b = self.as_bytes();
605        let b_len = b.len();
606        let vi_len = VarInt(b_len as u64).encode(s)?;
607        s.write_slice(b)?;
608        Ok(vi_len + b_len)
609    }
610}
611
612impl Encodable for &str {
613    #[inline]
614    fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error> {
615        let b = self.as_bytes();
616        let b_len = b.len();
617        let vi_len = VarInt(b_len as u64).encode(s)?;
618        s.write_slice(b)?;
619        Ok(vi_len + b_len)
620    }
621}
622
623impl Decodable for String {
624    #[inline]
625    fn decode<D: Read>(d: &mut D) -> Result<String, Error> {
626        match String::from_utf8(Decodable::decode(d)?) {
627            Ok(v) => Ok(v),
628            Err(_) => Err(Error::other("Invalid UTF-8 for string")),
629        }
630    }
631}
632
633/*
634impl Encodable for Cow<'static, str> {
635    #[inline]
636    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
637        let b = self.as_bytes();
638        let b_len = b.len();
639        let vi_len = VarInt(b_len as u64).encode(&mut s)?;
640        s.write_slice(b)?;
641        Ok(vi_len + b_len)
642    }
643}
644
645impl Decodable for Cow<'static, str> {
646    #[inline]
647    fn decode<D: Read>(d: D) -> Result<Cow<'static, str>, Error> {
648        match String::from_utf8(Decodable::decode(d)?) {
649            Ok(v) => v.map(Cow::Owned),
650            Err(_) => Err(Error::other("Invalid UTF-8 for string")),
651        }
652    }
653}
654*/
655
656#[cfg(test)]
657mod tests {
658    use super::{endian::*, *};
659    use futures_lite::AsyncWriteExt;
660
661    #[test]
662    fn serialize_int_test() {
663        // bool
664        assert_eq!(serialize(&false), vec![0u8]);
665        assert_eq!(serialize(&true), vec![1u8]);
666        // u8
667        assert_eq!(serialize(&1u8), vec![1u8]);
668        assert_eq!(serialize(&0u8), vec![0u8]);
669        assert_eq!(serialize(&255u8), vec![255u8]);
670        // u16
671        assert_eq!(serialize(&1u16), vec![1u8, 0]);
672        assert_eq!(serialize(&256u16), vec![0u8, 1]);
673        assert_eq!(serialize(&5000u16), vec![136u8, 19]);
674        // u32
675        assert_eq!(serialize(&1u32), vec![1u8, 0, 0, 0]);
676        assert_eq!(serialize(&256u32), vec![0u8, 1, 0, 0]);
677        assert_eq!(serialize(&5000u32), vec![136u8, 19, 0, 0]);
678        assert_eq!(serialize(&500000u32), vec![32u8, 161, 7, 0]);
679        assert_eq!(serialize(&168430090u32), vec![10u8, 10, 10, 10]);
680        // i32
681        assert_eq!(serialize(&-1i32), vec![255u8, 255, 255, 255]);
682        assert_eq!(serialize(&-256i32), vec![0u8, 255, 255, 255]);
683        assert_eq!(serialize(&-5000i32), vec![120u8, 236, 255, 255]);
684        assert_eq!(serialize(&-500000i32), vec![224u8, 94, 248, 255]);
685        assert_eq!(serialize(&-168430090i32), vec![246u8, 245, 245, 245]);
686        assert_eq!(serialize(&1i32), vec![1u8, 0, 0, 0]);
687        assert_eq!(serialize(&256i32), vec![0u8, 1, 0, 0]);
688        assert_eq!(serialize(&5000i32), vec![136u8, 19, 0, 0]);
689        assert_eq!(serialize(&500000i32), vec![32u8, 161, 7, 0]);
690        assert_eq!(serialize(&168430090i32), vec![10u8, 10, 10, 10]);
691        // u64
692        assert_eq!(serialize(&1u64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
693        assert_eq!(serialize(&256u64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
694        assert_eq!(serialize(&5000u64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
695        assert_eq!(serialize(&500000u64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
696        assert_eq!(serialize(&723401728380766730u64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
697        // i64
698        assert_eq!(serialize(&-1i64), vec![255u8, 255, 255, 255, 255, 255, 255, 255]);
699        assert_eq!(serialize(&-256i64), vec![0u8, 255, 255, 255, 255, 255, 255, 255]);
700        assert_eq!(serialize(&-5000i64), vec![120u8, 236, 255, 255, 255, 255, 255, 255]);
701        assert_eq!(serialize(&-500000i64), vec![224u8, 94, 248, 255, 255, 255, 255, 255]);
702        assert_eq!(
703            serialize(&-723401728380766730i64),
704            vec![246u8, 245, 245, 245, 245, 245, 245, 245]
705        );
706        assert_eq!(serialize(&1i64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
707        assert_eq!(serialize(&256i64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
708        assert_eq!(serialize(&5000i64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
709        assert_eq!(serialize(&500000i64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
710        assert_eq!(serialize(&723401728380766730i64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
711    }
712
713    #[test]
714    fn serialize_float_test() {
715        // f64
716        assert_eq!(serialize(&1.5f64), vec![0u8, 0, 0, 0, 0, 0, 248, 63]);
717        assert_eq!(serialize(&256.7f64), vec![51u8, 51, 51, 51, 51, 11, 112, 64]);
718        assert_eq!(serialize(&5000.21f64), vec![41u8, 92, 143, 194, 53, 136, 179, 64]);
719        assert_eq!(serialize(&500000.314f64), vec![76u8, 55, 137, 65, 129, 132, 30, 65]);
720        assert_eq!(serialize(&1102021.1102021f64), vec![111u8, 52, 54, 28, 197, 208, 48, 65]);
721        assert_eq!(
722            serialize(&723401728380766730.894612f64),
723            vec![20u8, 20, 20, 20, 20, 20, 164, 67]
724        );
725        assert_eq!(serialize(&-1.5f64), vec![0u8, 0, 0, 0, 0, 0, 248, 191]);
726        assert_eq!(serialize(&-256.7f64), vec![51u8, 51, 51, 51, 51, 11, 112, 192]);
727        assert_eq!(serialize(&-5000.21f64), vec![41u8, 92, 143, 194, 53, 136, 179, 192]);
728        assert_eq!(serialize(&-500000.314f64), vec![76u8, 55, 137, 65, 129, 132, 30, 193]);
729        assert_eq!(serialize(&-1102021.1102021f64), vec![111u8, 52, 54, 28, 197, 208, 48, 193]);
730        assert_eq!(
731            serialize(&-723401728380766730.894612f64),
732            vec![20u8, 20, 20, 20, 20, 20, 164, 195]
733        );
734        // f32
735        assert_eq!(serialize(&1.5f32), vec![0u8, 0, 192, 63]);
736        assert_eq!(serialize(&256.7f32), vec![154u8, 89, 128, 67]);
737        assert_eq!(serialize(&5000.21f32), vec![174u8, 65, 156, 69]);
738        assert_eq!(serialize(&500000.3f32), vec![10u8, 36, 244, 72]);
739        assert_eq!(serialize(&1102021.1f32), vec![41u8, 134, 134, 73]);
740        assert_eq!(serialize(&72340172838076673.9f32), vec![129u8, 128, 128, 91]);
741        assert_eq!(serialize(&-1.5f32), vec![0u8, 0, 192, 191]);
742        assert_eq!(serialize(&-256.7f32), vec![154u8, 89, 128, 195]);
743        assert_eq!(serialize(&-5000.21f32), vec![174u8, 65, 156, 197]);
744        assert_eq!(serialize(&-500000.3f32), vec![10u8, 36, 244, 200]);
745        assert_eq!(serialize(&-1102021.1f32), vec![41u8, 134, 134, 201]);
746        assert_eq!(serialize(&-72340172838076673.9f32), vec![129u8, 128, 128, 219]);
747    }
748
749    #[test]
750    fn serialize_varint_test() {
751        assert_eq!(serialize(&VarInt(10)), vec![10u8]);
752        assert_eq!(serialize(&VarInt(0xFC)), vec![0xFCu8]);
753        assert_eq!(serialize(&VarInt(0xFD)), vec![0xFDu8, 0xFD, 0]);
754        assert_eq!(serialize(&VarInt(0xFFF)), vec![0xFDu8, 0xFF, 0xF]);
755        assert_eq!(serialize(&VarInt(0xF0F0F0F)), vec![0xFEu8, 0xF, 0xF, 0xF, 0xF]);
756        assert_eq!(
757            serialize(&VarInt(0xF0F0F0F0F0E0)),
758            vec![0xFFu8, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0, 0]
759        );
760        assert_eq!(
761            test_varint_encode(0xFF, &u64_to_array_le(0x100000000)).unwrap(),
762            VarInt(0x100000000)
763        );
764        assert_eq!(test_varint_encode(0xFE, &u64_to_array_le(0x10000)).unwrap(), VarInt(0x10000));
765        assert_eq!(test_varint_encode(0xFD, &u64_to_array_le(0xFD)).unwrap(), VarInt(0xFD));
766
767        // Test that length calc is working correctly
768        test_varint_len(VarInt(0), 1);
769        test_varint_len(VarInt(0xFC), 1);
770        test_varint_len(VarInt(0xFD), 3);
771        test_varint_len(VarInt(0xFFFF), 3);
772        test_varint_len(VarInt(0x10000), 5);
773        test_varint_len(VarInt(0xFFFFFFFF), 5);
774        test_varint_len(VarInt(0xFFFFFFFF + 1), 9);
775        test_varint_len(VarInt(u64::MAX), 9);
776    }
777
778    fn test_varint_len(varint: VarInt, expected: usize) {
779        let mut encoder = Cursor::new(vec![]);
780        assert_eq!(varint.encode(&mut encoder).unwrap(), expected);
781        assert_eq!(varint.length(), expected);
782    }
783
784    fn test_varint_encode(n: u8, x: &[u8]) -> Result<VarInt, Error> {
785        let mut input = [0u8; 9];
786        input[0] = n;
787        input[1..x.len() + 1].copy_from_slice(x);
788        deserialize_partial::<VarInt>(&input).map(|t| t.0)
789    }
790
791    #[test]
792    fn deserialize_nonminimal_vec() {
793        // Check the edges for variant int
794        assert!(test_varint_encode(0xFF, &u64_to_array_le(0x100000000 - 1)).is_err());
795        assert!(test_varint_encode(0xFE, &u32_to_array_le(0x10000 - 1)).is_err());
796        assert!(test_varint_encode(0xFD, &u16_to_array_le(0xFD - 1)).is_err());
797        assert!(deserialize::<Vec<u8>>(&[0xfd, 0x00, 0x00]).is_err());
798        assert!(deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).is_err());
799        assert!(deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).is_err());
800        assert!(deserialize::<Vec<u8>>(&[0xfe, 0xff, 0x00, 0x00, 0x00]).is_err());
801        assert!(deserialize::<Vec<u8>>(&[0xfe, 0xff, 0xff, 0x00, 0x00]).is_err());
802        assert!(deserialize::<Vec<u8>>(&[0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
803            .is_err());
804        assert!(deserialize::<Vec<u8>>(&[0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00])
805            .is_err());
806
807        let mut vec_256 = vec![0; 259];
808        vec_256[0] = 0xfd;
809        vec_256[1] = 0x00;
810        vec_256[2] = 0x01;
811        assert!(deserialize::<Vec<u8>>(&vec_256).is_ok());
812
813        let mut vec_253 = vec![0; 256];
814        vec_253[0] = 0xfd;
815        vec_253[1] = 0xfd;
816        vec_253[2] = 0x00;
817        assert!(deserialize::<Vec<u8>>(&vec_253).is_ok());
818    }
819
820    #[test]
821    fn serialize_vector_test() {
822        assert_eq!(serialize(&vec![1u8, 2, 3]), vec![3u8, 1, 2, 3]);
823        assert_eq!(serialize(&vec![1u16, 2u16]), vec![2u8, 1, 0, 2, 0]);
824        assert_eq!(serialize(&vec![256u16, 5000u16]), vec![2u8, 0, 1, 136, 19]);
825        assert_eq!(
826            serialize(&vec![1u32, 256u32, 5000u32]),
827            vec![3u8, 1, 0, 0, 0, 0, 1, 0, 0, 136, 19, 0, 0]
828        );
829        assert_eq!(
830            serialize(&vec![1u64, 256u64, 5000u64, 500000u64]),
831            vec![
832                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,
833                161, 7, 0, 0, 0, 0, 0
834            ]
835        );
836        assert_eq!(serialize(&vec![-1i8]), vec![1u8, 255]);
837        assert_eq!(serialize(&vec![1i8, -2i8, -3i8]), vec![3u8, 1, 254, 253]);
838        assert_eq!(serialize(&vec![-1i32]), vec![1u8, 255, 255, 255, 255]);
839        assert_eq!(serialize(&vec![-1i32, -256]), vec![2u8, 255, 255, 255, 255, 0, 255, 255, 255]);
840        assert_eq!(
841            serialize(&vec![-1i32, -2i32, -3i32]),
842            vec![3u8, 255, 255, 255, 255, 254, 255, 255, 255, 253, 255, 255, 255]
843        );
844        assert_eq!(
845            serialize(&vec![-1i64, -256i64, -5000i64, -500000i64]),
846            vec![
847                4u8, 255, 255, 255, 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255,
848                120, 236, 255, 255, 255, 255, 255, 255, 224, 94, 248, 255, 255, 255, 255, 255
849            ]
850        );
851    }
852
853    #[test]
854    fn serialize_strbuf_test() {
855        assert_eq!(serialize(&"Andrew".to_string()), vec![6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]);
856    }
857
858    #[test]
859    fn deserialize_int_test() {
860        // bool
861        assert!((deserialize(&[58u8, 0]) as Result<bool, Error>).is_err());
862        assert_eq!(deserialize(&[58u8]).ok(), Some(true));
863        assert_eq!(deserialize(&[1u8]).ok(), Some(true));
864        assert_eq!(deserialize(&[0u8]).ok(), Some(false));
865        assert!((deserialize(&[0u8, 1]) as Result<bool, Error>).is_err());
866
867        // u8
868        assert_eq!(deserialize(&[58u8]).ok(), Some(58u8));
869
870        // u16
871        assert_eq!(deserialize(&[0x01u8, 0x02]).ok(), Some(0x0201u16));
872        assert_eq!(deserialize(&[0xABu8, 0xCD]).ok(), Some(0xCDABu16));
873        assert_eq!(deserialize(&[0xA0u8, 0x0D]).ok(), Some(0xDA0u16));
874        let failure16: Result<u16, Error> = deserialize(&[1u8]);
875        assert!(failure16.is_err());
876
877        // u32
878        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABu32));
879        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD]).ok(), Some(0xCDAB0DA0u32));
880        let failure32: Result<u32, Error> = deserialize(&[1u8, 2, 3]);
881        assert!(failure32.is_err());
882
883        assert_eq!(deserialize(&[0x78u8, 0xec, 0xff, 0xff]).ok(), Some(-5000i32));
884        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABi32));
885        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0x2D]).ok(), Some(0x2DAB0DA0i32));
886        let failurei32: Result<i32, Error> = deserialize(&[1u8, 2, 3]);
887        assert!(failurei32.is_err());
888
889        // u64
890        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABu64));
891        assert_eq!(
892            deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
893            Some(0x99000099CDAB0DA0u64)
894        );
895        let failure64: Result<u64, Error> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
896        assert!(failure64.is_err());
897        assert_eq!(
898            deserialize(&[0xe0, 0x5e, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff]).ok(),
899            Some(-500000i64)
900        );
901        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABi64));
902        assert_eq!(
903            deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
904            Some(-0x66ffff663254f260i64)
905        );
906        let failurei64: Result<i64, Error> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
907        assert!(failurei64.is_err());
908    }
909    #[test]
910    fn deserialize_vec_test() {
911        assert_eq!(deserialize(&[3u8, 2, 3, 4]).ok(), Some(vec![2u8, 3, 4]));
912        assert!((deserialize(&[4u8, 2, 3, 4, 5, 6]) as Result<Vec<u8>, Error>).is_err());
913    }
914
915    #[test]
916    fn deserialize_strbuf_test() {
917        assert_eq!(
918            deserialize(&[6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]).ok(),
919            Some("Andrew".to_string())
920        );
921    }
922
923    #[test]
924    fn encode_payload_test() -> Result<(), Error> {
925        let mut i32_buf1 = vec![];
926        let mut i32_buf2 = vec![];
927        1_i32.encode(&mut i32_buf1)?;
928        2_i32.encode(&mut i32_buf2)?;
929
930        let mut string_buf = vec![];
931        b"Hello World".encode(&mut string_buf)?;
932
933        /*
934        eprintln!("{:?}", i32_buf1);
935        eprintln!("{:?}", i32_buf2);
936        eprintln!("{:?}", string_buf);
937        */
938
939        let mut buf = vec![];
940        let mut buf_verify = vec![];
941        buf_verify.extend_from_slice(&i32_buf1);
942        buf_verify.extend_from_slice(&i32_buf2);
943        buf_verify.extend_from_slice(&string_buf);
944
945        encode_payload!(&mut buf, 1_i32, 2_i32, b"Hello World");
946        assert_eq!(buf, buf_verify);
947
948        let mut f64_buf = vec![];
949        let mut i64_buf = vec![];
950        let mut bool_buf = vec![];
951        let mut u32_buf = vec![];
952        let mut array_buf = vec![];
953        1.5f64.encode(&mut f64_buf)?;
954        (-1i64).encode(&mut i64_buf)?;
955        true.encode(&mut bool_buf)?;
956        0x10000_u32.encode(&mut u32_buf)?;
957        [0xfe, 0xff, 0x00, 0x00, 0x00].encode(&mut array_buf)?;
958
959        /*
960        eprintln!("{:?}", f64_buf);
961        eprintln!("{:?}", i64_buf);
962        eprintln!("{:?}", bool_buf);
963        eprintln!("{:?}", u32_buf);
964        eprintln!("{:?}", array_buf);
965        */
966
967        let mut buf = vec![];
968        let mut buf_verify = vec![];
969        buf_verify.extend_from_slice(&f64_buf);
970        buf_verify.extend_from_slice(&i64_buf);
971        buf_verify.extend_from_slice(&bool_buf);
972        buf_verify.extend_from_slice(&u32_buf);
973        buf_verify.extend_from_slice(&array_buf);
974        encode_payload!(&mut buf, 1.5f64, -1i64, true, 0x10000_u32, [0xfe, 0xff, 0x00, 0x00, 0x00]);
975        assert_eq!(buf, buf_verify);
976
977        Ok(())
978    }
979
980    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
981    enum TestEnum0 {
982        First,
983        Second,
984        Third,
985    }
986
987    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
988    enum TestEnum1 {
989        First = 0x01,
990        Second = 0x03,
991        Third = 0xf1,
992        Fourth = 0xfe,
993    }
994
995    #[test]
996    fn derive_serialize_deserialize_enum() {
997        let first = serialize(&TestEnum0::First);
998        let second = serialize(&TestEnum0::Second);
999        let third = serialize(&TestEnum0::Third);
1000        assert_eq!(deserialize::<TestEnum0>(&first).unwrap(), TestEnum0::First);
1001        assert_eq!(deserialize::<TestEnum0>(&second).unwrap(), TestEnum0::Second);
1002        assert_eq!(deserialize::<TestEnum0>(&third).unwrap(), TestEnum0::Third);
1003
1004        let first = serialize(&TestEnum1::First);
1005        let second = serialize(&TestEnum1::Second);
1006        let third = serialize(&TestEnum1::Third);
1007        let fourth = serialize(&TestEnum1::Fourth);
1008        assert_eq!(first, [0x01]);
1009        assert_eq!(second, [0x03]);
1010        assert_eq!(third, [0xf1]);
1011        assert_eq!(fourth, [0xfe]);
1012    }
1013
1014    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
1015    struct TestStruct0 {
1016        foo: u64,
1017        bar: bool,
1018        baz: String,
1019    }
1020
1021    #[derive(Debug, PartialEq, SerialEncodable, SerialDecodable)]
1022    struct TestStruct1(String);
1023
1024    #[test]
1025    fn derive_serialize_deserialize_struct() {
1026        let foo = 44;
1027        let bar = true;
1028        let baz = String::from("foobarbaz");
1029        let ts0 = TestStruct0 { foo, bar, baz: baz.clone() };
1030        let ts0_s = serialize(&ts0);
1031        let ts0_n = deserialize::<TestStruct0>(&ts0_s).unwrap();
1032        assert_eq!(foo, ts0_n.foo);
1033        assert_eq!(bar, ts0_n.bar);
1034        assert_eq!(baz, ts0_n.baz);
1035        assert_eq!(ts0, ts0_n);
1036        assert_eq!(ts0_n, TestStruct0 { foo, bar, baz: baz.clone() });
1037
1038        let ts1 = TestStruct1(baz.clone());
1039        let ts1_s = serialize(&ts1);
1040        let ts1_n = deserialize::<TestStruct1>(&ts1_s).unwrap();
1041        assert_eq!(ts1, ts1_n);
1042        assert_eq!(ts1_n, TestStruct1(baz));
1043    }
1044}
darkfi_serial/lib.rs

darkfi_serial/
lib.rs
