Merge branch 'yaml-test-downloads' into cached-tree-hash

eth2/utils/ssz/src/decode.rs

@@ -13,16 +13,23 @@ pub trait Decodable: Sized {
 
 /// Decode the given bytes for the given type
 ///
-/// The single ssz encoded value will be decoded as the given type at the
-/// given index.
-pub fn decode_ssz<T>(ssz_bytes: &[u8], index: usize) -> Result<(T, usize), DecodeError>
+/// The single ssz encoded value/container/list will be decoded as the given type,
+/// by recursively calling `ssz_decode`.
+/// Check on totality for underflowing the length of bytes and overflow checks done per container
+pub fn decode<T>(ssz_bytes: &[u8]) -> Result<(T), DecodeError>
 where
     T: Decodable,
 {
-    if index >= ssz_bytes.len() {
-        return Err(DecodeError::TooShort);
+    let (decoded, i): (T, usize) = match T::ssz_decode(ssz_bytes, 0) {
+        Err(e) => return Err(e),
+        Ok(v) => v,
+    };
+
+    if i < ssz_bytes.len() {
+        return Err(DecodeError::TooLong);
     }
-    T::ssz_decode(ssz_bytes, index)
+
+    Ok(decoded)
 }
 
 /// Decode a vector (list) of encoded bytes.
@@ -65,7 +72,7 @@ where
 }
 
 /// Given some number of bytes, interpret the first four
-/// bytes as a 32-bit big-endian integer and return the
+/// bytes as a 32-bit little-endian integer and return the
 /// result.
 pub fn decode_length(
     bytes: &[u8],
@@ -82,7 +89,7 @@ pub fn decode_length(
         .take(index + length_bytes)
         .skip(index)
     {
-        let offset = (index + length_bytes - i - 1) * 8;
+        let offset = (i - index) * 8;
         len |= (*byte as usize) << offset;
     }
     Ok(len)
@@ -90,18 +97,18 @@ pub fn decode_length(
 
 #[cfg(test)]
 mod tests {
-    use super::super::encode::encode_length;
+    use super::super::encode::*;
     use super::*;
 
     #[test]
     fn test_ssz_decode_length() {
-        let decoded = decode_length(&vec![0, 0, 0, 1], 0, LENGTH_BYTES);
+        let decoded = decode_length(&vec![1, 0, 0, 0], 0, LENGTH_BYTES);
         assert_eq!(decoded.unwrap(), 1);
 
-        let decoded = decode_length(&vec![0, 0, 1, 0], 0, LENGTH_BYTES);
+        let decoded = decode_length(&vec![0, 1, 0, 0], 0, LENGTH_BYTES);
         assert_eq!(decoded.unwrap(), 256);
 
-        let decoded = decode_length(&vec![0, 0, 1, 255], 0, LENGTH_BYTES);
+        let decoded = decode_length(&vec![255, 1, 0, 0], 0, LENGTH_BYTES);
         assert_eq!(decoded.unwrap(), 511);
 
         let decoded = decode_length(&vec![255, 255, 255, 255], 0, LENGTH_BYTES);
@@ -132,21 +139,35 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_encode_decode_ssz_list() {
+        let test_vec: Vec<u16> = vec![256; 12];
+        let mut stream = SszStream::new();
+        stream.append_vec(&test_vec);
+        let ssz = stream.drain();
+
+        // u16
+        let decoded: (Vec<u16>, usize) = decode_ssz_list(&ssz, 0).unwrap();
+
+        assert_eq!(decoded.0, test_vec);
+        assert_eq!(decoded.1, LENGTH_BYTES + (12 * 2));
+    }
+
     #[test]
     fn test_decode_ssz_list() {
         // u16
         let v: Vec<u16> = vec![10, 10, 10, 10];
         let decoded: (Vec<u16>, usize) =
-            decode_ssz_list(&vec![0, 0, 0, 8, 0, 10, 0, 10, 0, 10, 0, 10], 0).unwrap();
+            decode_ssz_list(&vec![8, 0, 0, 0, 10, 0, 10, 0, 10, 0, 10, 0], 0).unwrap();
 
         assert_eq!(decoded.0, v);
-        assert_eq!(decoded.1, 12);
+        assert_eq!(decoded.1, LENGTH_BYTES + (4 * 2));
 
         // u32
         let v: Vec<u32> = vec![10, 10, 10, 10];
         let decoded: (Vec<u32>, usize) = decode_ssz_list(
             &vec![
-                0, 0, 0, 16, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10,
+                16, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 00,
             ],
             0,
         )
@@ -158,36 +179,37 @@ mod tests {
         let v: Vec<u64> = vec![10, 10, 10, 10];
         let decoded: (Vec<u64>, usize) = decode_ssz_list(
             &vec![
-                0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0,
-                10, 0, 0, 0, 0, 0, 0, 0, 10,
+                32, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0,
+                0, 0, 10, 0, 0, 0, 0, 0, 0, 0,
             ],
             0,
         )
         .unwrap();
         assert_eq!(decoded.0, v);
-        assert_eq!(decoded.1, 36);
+        assert_eq!(decoded.1, LENGTH_BYTES + (8 * 4));
 
         // Check that it can accept index
         let v: Vec<usize> = vec![15, 15, 15, 15];
+        let offset = 10;
         let decoded: (Vec<usize>, usize) = decode_ssz_list(
             &vec![
-                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0,
-                0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 32, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0,
+                0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0,
             ],
-            10,
+            offset,
         )
         .unwrap();
         assert_eq!(decoded.0, v);
-        assert_eq!(decoded.1, 46);
+        assert_eq!(decoded.1, offset + LENGTH_BYTES + (8 * 4));
 
         // Check that length > bytes throws error
         let decoded: Result<(Vec<usize>, usize), DecodeError> =
-            decode_ssz_list(&vec![0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 15], 0);
+            decode_ssz_list(&vec![32, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0], 0);
         assert_eq!(decoded, Err(DecodeError::TooShort));
 
         // Check that incorrect index throws error
         let decoded: Result<(Vec<usize>, usize), DecodeError> =
-            decode_ssz_list(&vec![0, 0, 0, 0, 0, 0, 0, 15], 16);
+            decode_ssz_list(&vec![15, 0, 0, 0, 0, 0, 0, 0], 16);
         assert_eq!(decoded, Err(DecodeError::TooShort));
     }
 }

eth2/utils/ssz/src/encode.rs

@@ -70,13 +70,13 @@ impl SszStream {
 /// Encode some length into a ssz size prefix.
 ///
 /// The ssz size prefix is 4 bytes, which is treated as a continuious
-/// 32bit big-endian integer.
+/// 32bit little-endian integer.
 pub fn encode_length(len: usize, length_bytes: usize) -> Vec<u8> {
     assert!(length_bytes > 0); // For sanity
     assert!((len as usize) < 2usize.pow(length_bytes as u32 * 8));
     let mut header: Vec<u8> = vec![0; length_bytes];
     for (i, header_byte) in header.iter_mut().enumerate() {
-        let offset = (length_bytes - i - 1) * 8;
+        let offset = i * 8;
         *header_byte = ((len >> offset) & 0xff) as u8;
     }
     header
@@ -95,15 +95,27 @@ mod tests {
     #[test]
     fn test_encode_length_4_bytes() {
         assert_eq!(encode_length(0, LENGTH_BYTES), vec![0; 4]);
-        assert_eq!(encode_length(1, LENGTH_BYTES), vec![0, 0, 0, 1]);
-        assert_eq!(encode_length(255, LENGTH_BYTES), vec![0, 0, 0, 255]);
-        assert_eq!(encode_length(256, LENGTH_BYTES), vec![0, 0, 1, 0]);
+        assert_eq!(encode_length(1, LENGTH_BYTES), vec![1, 0, 0, 0]);
+        assert_eq!(encode_length(255, LENGTH_BYTES), vec![255, 0, 0, 0]);
+        assert_eq!(encode_length(256, LENGTH_BYTES), vec![0, 1, 0, 0]);
         assert_eq!(
             encode_length(4294967295, LENGTH_BYTES), // 2^(3*8) - 1
             vec![255, 255, 255, 255]
         );
     }
 
+    #[test]
+    fn test_encode_lower_length() {
+        assert_eq!(encode_length(0, LENGTH_BYTES - 2), vec![0; 2]);
+        assert_eq!(encode_length(1, LENGTH_BYTES - 2), vec![1, 0]);
+    }
+
+    #[test]
+    fn test_encode_higher_length() {
+        assert_eq!(encode_length(0, LENGTH_BYTES + 2), vec![0; 6]);
+        assert_eq!(encode_length(1, LENGTH_BYTES + 2), vec![1, 0, 0, 0, 0, 0]);
+    }
+
     #[test]
     #[should_panic]
     fn test_encode_length_4_bytes_panic() {
@@ -117,8 +129,42 @@ mod tests {
         stream.append_vec(&test_vec);
         let ssz = stream.drain();
 
-        assert_eq!(ssz.len(), 4 + (12 * 2));
-        assert_eq!(ssz[0..4], *vec![0, 0, 0, 24]);
-        assert_eq!(ssz[4..6], *vec![1, 0]);
+        assert_eq!(ssz.len(), LENGTH_BYTES + (12 * 2));
+        assert_eq!(ssz[0..4], *vec![24, 0, 0, 0]);
+        assert_eq!(ssz[4..6], *vec![0, 1]);
+    }
+
+    #[test]
+    fn test_encode_mixed_prefixed() {
+        let test_vec: Vec<u16> = vec![100, 200];
+        let test_value: u8 = 5;
+
+        let mut stream = SszStream::new();
+        stream.append_vec(&test_vec);
+        stream.append(&test_value);
+        let ssz = stream.drain();
+
+        assert_eq!(ssz.len(), LENGTH_BYTES + (2 * 2) + 1);
+        assert_eq!(ssz[0..4], *vec![4, 0, 0, 0]);
+        assert_eq!(ssz[4..6], *vec![100, 0]);
+        assert_eq!(ssz[6..8], *vec![200, 0]);
+        assert_eq!(ssz[8], 5);
+    }
+
+    #[test]
+    fn test_encode_mixed_postfixed() {
+        let test_value: u8 = 5;
+        let test_vec: Vec<u16> = vec![100, 200];
+
+        let mut stream = SszStream::new();
+        stream.append(&test_value);
+        stream.append_vec(&test_vec);
+        let ssz = stream.drain();
+
+        assert_eq!(ssz.len(), 1 + LENGTH_BYTES + (2 * 2));
+        assert_eq!(ssz[0], 5);
+        assert_eq!(ssz[1..5], *vec![4, 0, 0, 0]);
+        assert_eq!(ssz[5..7], *vec![100, 0]);
+        assert_eq!(ssz[7..9], *vec![200, 0]);
     }
 }

eth2/utils/ssz/src/impl_decode.rs

@@ -12,7 +12,7 @@ macro_rules! impl_decodable_for_uint {
                     let end_bytes = index + max_bytes;
                     let mut result: $type = 0;
                     for (i, byte) in bytes.iter().enumerate().take(end_bytes).skip(index) {
-                        let offset = (end_bytes - i - 1) * 8;
+                        let offset = (i - index) * 8;
                         result |= ($type::from(*byte)) << offset;
                     }
                     Ok((result, end_bytes))
@@ -65,7 +65,7 @@ impl Decodable for bool {
         } else {
             let result = match bytes[index] {
                 0b0000_0000 => false,
-                0b1000_0000 => true,
+                0b0000_0001 => true,
                 _ => return Err(DecodeError::Invalid),
             };
             Ok((result, index + 1))
@@ -104,7 +104,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::super::{decode_ssz, DecodeError};
+    use super::super::{decode, DecodeError};
     use super::*;
 
     #[test]
@@ -138,139 +138,169 @@ mod tests {
     fn test_ssz_decode_u16() {
         let ssz = vec![0, 0];
 
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (u16, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(result, 0);
         assert_eq!(index, 2);
 
-        let ssz = vec![0, 16];
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
+        let ssz = vec![16, 0];
+        let (result, index): (u16, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(result, 16);
         assert_eq!(index, 2);
 
-        let ssz = vec![1, 0];
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
+        let ssz = vec![0, 1];
+        let (result, index): (u16, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(result, 256);
         assert_eq!(index, 2);
 
         let ssz = vec![255, 255];
-        let (result, index): (u16, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (u16, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 2);
         assert_eq!(result, 65535);
 
         let ssz = vec![1];
-        let result: Result<(u16, usize), DecodeError> = decode_ssz(&ssz, 0);
+        let result: Result<(u16, usize), DecodeError> = <_>::ssz_decode(&ssz, 0);
         assert_eq!(result, Err(DecodeError::TooShort));
     }
 
     #[test]
     fn test_ssz_decode_u32() {
         let ssz = vec![0, 0, 0, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (u32, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(result, 0);
         assert_eq!(index, 4);
 
-        let ssz = vec![0, 0, 1, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
+        let ssz = vec![0, 1, 0, 0];
+        let (result, index): (u32, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 4);
         assert_eq!(result, 256);
 
-        let ssz = vec![255, 255, 255, 0, 0, 1, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 3).unwrap();
+        let ssz = vec![255, 255, 255, 0, 1, 0, 0];
+        let (result, index): (u32, usize) = <_>::ssz_decode(&ssz, 3).unwrap();
         assert_eq!(index, 7);
         assert_eq!(result, 256);
 
-        let ssz = vec![0, 200, 1, 0];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
+        let ssz = vec![0, 1, 200, 0];
+        let (result, index): (u32, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 4);
         assert_eq!(result, 13107456);
 
         let ssz = vec![255, 255, 255, 255];
-        let (result, index): (u32, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (u32, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 4);
         assert_eq!(result, 4294967295);
 
-        let ssz = vec![0, 0, 1];
-        let result: Result<(u32, usize), DecodeError> = decode_ssz(&ssz, 0);
+        let ssz = vec![1, 0, 0];
+        let result: Result<(u32, usize), DecodeError> = <_>::ssz_decode(&ssz, 0);
         assert_eq!(result, Err(DecodeError::TooShort));
     }
 
     #[test]
     fn test_ssz_decode_u64() {
         let ssz = vec![0, 0, 0, 0, 0, 0, 0, 0];
-        let (result, index): (u64, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (u64, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 8);
         assert_eq!(result, 0);
 
         let ssz = vec![255, 255, 255, 255, 255, 255, 255, 255];
-        let (result, index): (u64, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (u64, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 8);
         assert_eq!(result, 18446744073709551615);
 
-        let ssz = vec![0, 0, 8, 255, 0, 0, 0, 0, 0, 0, 0];
-        let (result, index): (u64, usize) = decode_ssz(&ssz, 3).unwrap();
+        let ssz = vec![0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 255];
+        let (result, index): (u64, usize) = <_>::ssz_decode(&ssz, 3).unwrap();
         assert_eq!(index, 11);
         assert_eq!(result, 18374686479671623680);
 
         let ssz = vec![0, 0, 0, 0, 0, 0, 0];
-        let result: Result<(u64, usize), DecodeError> = decode_ssz(&ssz, 0);
+        let result: Result<(u64, usize), DecodeError> = <_>::ssz_decode(&ssz, 0);
         assert_eq!(result, Err(DecodeError::TooShort));
     }
 
     #[test]
     fn test_ssz_decode_usize() {
         let ssz = vec![0, 0, 0, 0, 0, 0, 0, 0];
-        let (result, index): (usize, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (usize, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 8);
         assert_eq!(result, 0);
 
         let ssz = vec![0, 0, 8, 255, 255, 255, 255, 255, 255, 255, 255];
-        let (result, index): (usize, usize) = decode_ssz(&ssz, 3).unwrap();
+        let (result, index): (usize, usize) = <_>::ssz_decode(&ssz, 3).unwrap();
         assert_eq!(index, 11);
         assert_eq!(result, 18446744073709551615);
 
         let ssz = vec![255, 255, 255, 255, 255, 255, 255, 255, 255];
-        let (result, index): (usize, usize) = decode_ssz(&ssz, 0).unwrap();
+        let (result, index): (usize, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 8);
         assert_eq!(result, 18446744073709551615);
 
         let ssz = vec![0, 0, 0, 0, 0, 0, 1];
-        let result: Result<(usize, usize), DecodeError> = decode_ssz(&ssz, 0);
+        let result: Result<(usize, usize), DecodeError> = <_>::ssz_decode(&ssz, 0);
         assert_eq!(result, Err(DecodeError::TooShort));
     }
 
     #[test]
     fn test_decode_ssz_bounds() {
-        let err: Result<(u16, usize), DecodeError> = decode_ssz(&vec![1], 2);
+        let err: Result<(u16, usize), DecodeError> = <_>::ssz_decode(&vec![1], 2);
         assert_eq!(err, Err(DecodeError::TooShort));
 
-        let err: Result<(u16, usize), DecodeError> = decode_ssz(&vec![0, 0, 0, 0], 3);
+        let err: Result<(u16, usize), DecodeError> = <_>::ssz_decode(&vec![0, 0, 0, 0], 3);
         assert_eq!(err, Err(DecodeError::TooShort));
 
-        let result: u16 = decode_ssz(&vec![0, 0, 0, 0, 1], 3).unwrap().0;
+        let result: u16 = <_>::ssz_decode(&vec![0, 0, 0, 1, 0], 3).unwrap().0;
         assert_eq!(result, 1);
     }
 
     #[test]
     fn test_decode_ssz_bool() {
-        let ssz = vec![0b0000_0000, 0b1000_0000];
-        let (result, index): (bool, usize) = decode_ssz(&ssz, 0).unwrap();
+        let ssz = vec![0b0000_0000, 0b0000_0001];
+        let (result, index): (bool, usize) = <_>::ssz_decode(&ssz, 0).unwrap();
         assert_eq!(index, 1);
         assert_eq!(result, false);
 
-        let (result, index): (bool, usize) = decode_ssz(&ssz, 1).unwrap();
+        let (result, index): (bool, usize) = <_>::ssz_decode(&ssz, 1).unwrap();
         assert_eq!(index, 2);
         assert_eq!(result, true);
 
         let ssz = vec![0b0100_0000];
-        let result: Result<(bool, usize), DecodeError> = decode_ssz(&ssz, 0);
+        let result: Result<(bool, usize), DecodeError> = <_>::ssz_decode(&ssz, 0);
         assert_eq!(result, Err(DecodeError::Invalid));
+
+        let ssz = vec![];
+        let result: Result<(bool, usize), DecodeError> = <_>::ssz_decode(&ssz, 0);
+        assert_eq!(result, Err(DecodeError::TooShort));
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_decode_ssz_list_underflow() {
+        // SSZ encoded (u16::[1, 1, 1], u16::2)
+        let mut encoded = vec![6, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 0];
+        let (decoded_array, i): (Vec<u16>, usize) = <_>::ssz_decode(&encoded, 0).unwrap();
+        let (decoded_u16, i): (u16, usize) = <_>::ssz_decode(&encoded, i).unwrap();
+        assert_eq!(decoded_array, vec![1, 1, 1]);
+        assert_eq!(decoded_u16, 2);
+        assert_eq!(i, 12);
+
+        // Underflow
+        encoded[0] = 4; // change length to 4 from 6
+        let (decoded_array, i): (Vec<u16>, usize) = <_>::ssz_decode(&encoded, 0).unwrap();
+        let (decoded_u16, _): (u16, usize) = <_>::ssz_decode(&encoded, i).unwrap();
+        assert_eq!(decoded_array, vec![1, 1]);
+        assert_eq!(decoded_u16, 2);
+    }
+
+    #[test]
+    fn test_decode_too_long() {
+        let encoded = vec![6, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2];
+        let decoded_array: Result<Vec<u16>, DecodeError> = decode(&encoded);
+        assert_eq!(decoded_array, Err(DecodeError::TooLong));
     }
 
     #[test]
     fn test_decode_u8_array() {
         let ssz = vec![0, 1, 2, 3];
-        let (result, index): ([u8; 4], usize) = decode_ssz(&ssz, 0).unwrap();
-        assert_eq!(index, 4);
+        let result: [u8; 4] = decode(&ssz).unwrap();
+        assert_eq!(result.len(), 4);
         assert_eq!(result, [0, 1, 2, 3]);
     }
 }

eth2/utils/ssz/src/impl_encode.rs

@@ -27,9 +27,9 @@ macro_rules! impl_encodable_for_uint {
                 // Match bit size with encoding
                 match $bit_size {
                     8 => buf.put_u8(*self as u8),
-                    16 => buf.put_u16_be(*self as u16),
-                    32 => buf.put_u32_be(*self as u32),
-                    64 => buf.put_u64_be(*self as u64),
+                    16 => buf.put_u16_le(*self as u16),
+                    32 => buf.put_u32_le(*self as u32),
+                    64 => buf.put_u64_le(*self as u64),
                     _ => {}
                 }
 
@@ -61,7 +61,7 @@ impl_encodable_for_u8_array!(4);
 
 impl Encodable for bool {
     fn ssz_append(&self, s: &mut SszStream) {
-        let byte = if *self { 0b1000_0000 } else { 0b0000_0000 };
+        let byte = if *self { 0b0000_0001 } else { 0b0000_0000 };
         s.append_encoded_raw(&[byte]);
     }
 }
@@ -136,17 +136,17 @@ mod tests {
         let x: u16 = 1;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 1]);
+        assert_eq!(ssz.drain(), vec![1, 0]);
 
         let x: u16 = 100;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 100]);
+        assert_eq!(ssz.drain(), vec![100, 0]);
 
         let x: u16 = 1 << 8;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![1, 0]);
+        assert_eq!(ssz.drain(), vec![0, 1]);
 
         let x: u16 = 65535;
         let mut ssz = SszStream::new();
@@ -159,22 +159,22 @@ mod tests {
         let x: u32 = 1;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 1]);
+        assert_eq!(ssz.drain(), vec![1, 0, 0, 0]);
 
         let x: u32 = 100;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 100]);
+        assert_eq!(ssz.drain(), vec![100, 0, 0, 0]);
 
         let x: u32 = 1 << 16;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 1, 0, 0]);
+        assert_eq!(ssz.drain(), vec![0, 0, 1, 0]);
 
         let x: u32 = 1 << 24;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![1, 0, 0, 0]);
+        assert_eq!(ssz.drain(), vec![0, 0, 0, 1]);
 
         let x: u32 = !0;
         let mut ssz = SszStream::new();
@@ -187,17 +187,17 @@ mod tests {
         let x: u64 = 1;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 1]);
+        assert_eq!(ssz.drain(), vec![1, 0, 0, 0, 0, 0, 0, 0]);
 
         let x: u64 = 100;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 100]);
+        assert_eq!(ssz.drain(), vec![100, 0, 0, 0, 0, 0, 0, 0]);
 
         let x: u64 = 1 << 32;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 1, 0, 0, 0, 0]);
+        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 1, 0, 0, 0]);
 
         let x: u64 = !0;
         let mut ssz = SszStream::new();
@@ -210,17 +210,17 @@ mod tests {
         let x: usize = 1;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 1]);
+        assert_eq!(ssz.drain(), vec![1, 0, 0, 0, 0, 0, 0, 0]);
 
         let x: usize = 100;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 0, 0, 0, 100]);
+        assert_eq!(ssz.drain(), vec![100, 0, 0, 0, 0, 0, 0, 0]);
 
         let x: usize = 1 << 32;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0, 0, 0, 1, 0, 0, 0, 0]);
+        assert_eq!(ssz.drain(), vec![0, 0, 0, 0, 1, 0, 0, 0]);
 
         let x: usize = !0;
         let mut ssz = SszStream::new();
@@ -228,6 +228,27 @@ mod tests {
         assert_eq!(ssz.drain(), vec![255, 255, 255, 255, 255, 255, 255, 255]);
     }
 
+    #[test]
+    fn test_ssz_mixed() {
+        let mut stream = SszStream::new();
+
+        let h = Address::zero();
+        let a: u8 = 100;
+        let b: u16 = 65535;
+        let c: u32 = 1 << 24;
+
+        stream.append(&h);
+        stream.append(&a);
+        stream.append(&b);
+        stream.append(&c);
+
+        let ssz = stream.drain();
+        assert_eq!(ssz[0..20], *vec![0; 20]);
+        assert_eq!(ssz[20], 100);
+        assert_eq!(ssz[21..23], *vec![255, 255]);
+        assert_eq!(ssz[23..27], *vec![0, 0, 0, 1]);
+    }
+
     #[test]
     fn test_ssz_encode_bool() {
         let x: bool = false;
@@ -238,7 +259,7 @@ mod tests {
         let x: bool = true;
         let mut ssz = SszStream::new();
         ssz.append(&x);
-        assert_eq!(ssz.drain(), vec![0b1000_0000]);
+        assert_eq!(ssz.drain(), vec![0b0000_0001]);
     }
 
     #[test]

eth2/utils/ssz/src/lib.rs

@@ -20,7 +20,7 @@ mod impl_decode;
 mod impl_encode;
 mod impl_tree_hash;
 
-pub use crate::decode::{decode_ssz, decode_ssz_list, Decodable, DecodeError};
+pub use crate::decode::{decode, decode_ssz_list, Decodable, DecodeError};
 pub use crate::encode::{Encodable, SszStream};
 pub use crate::signed_root::SignedRoot;
 pub use crate::tree_hash::{merkle_hash, TreeHash};
@@ -39,3 +39,193 @@ where
     ssz_stream.append(val);
     ssz_stream.drain()
 }
+
+#[cfg(test)]
+mod tests {
+    extern crate hex;
+    extern crate yaml_rust;
+
+    use self::yaml_rust::yaml;
+    use super::*;
+    use std::{fs::File, io::prelude::*, path::PathBuf};
+
+    #[test]
+    pub fn test_vector_uint_bounds() {
+        let mut file = {
+            let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            file_path_buf.push("src/test_vectors/uint_bounds.yaml");
+
+            File::open(file_path_buf).unwrap()
+        };
+        let mut yaml_str = String::new();
+        file.read_to_string(&mut yaml_str).unwrap();
+        let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
+        let doc = &docs[0];
+
+        // Load test cases
+        let test_cases = doc["test_cases"].clone();
+
+        for test_case in test_cases {
+            // Only the valid cases are checked as parse::<uX>() will fail for all invalid cases
+            if test_case["valid"].as_bool().unwrap() {
+                // Convert test vector 'ssz' encoded yaml to Vec<u8>
+                let ssz = test_case["ssz"].as_str().unwrap().trim_start_matches("0x");
+                let test_vector_bytes = hex::decode(ssz).unwrap();
+
+                // Convert test vector 'value' to ssz encoded bytes
+                let mut bytes: Vec<u8>;
+                match test_case["type"].as_str().unwrap() {
+                    "uint8" => {
+                        let value: u8 = test_case["value"].as_str().unwrap().parse::<u8>().unwrap();
+                        bytes = ssz_encode::<u8>(&value); // check encoding
+
+                        // Check decoding
+                        let decoded = decode::<u8>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    "uint16" => {
+                        let value: u16 =
+                            test_case["value"].as_str().unwrap().parse::<u16>().unwrap();
+                        bytes = ssz_encode::<u16>(&value);
+
+                        // Check decoding
+                        let decoded = decode::<u16>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    "uint32" => {
+                        let value: u32 =
+                            test_case["value"].as_str().unwrap().parse::<u32>().unwrap();
+                        bytes = ssz_encode::<u32>(&value);
+
+                        // Check decoding
+                        let decoded = decode::<u32>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    "uint64" => {
+                        let value: u64 =
+                            test_case["value"].as_str().unwrap().parse::<u64>().unwrap();
+                        bytes = ssz_encode::<u64>(&value);
+
+                        // Check decoding
+                        let decoded = decode::<u64>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    _ => continue,
+                };
+                assert_eq!(test_vector_bytes, bytes);
+            }
+        }
+    }
+
+    #[test]
+    pub fn test_vector_uint_random() {
+        let mut file = {
+            let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            file_path_buf.push("src/test_vectors/uint_random.yaml");
+
+            File::open(file_path_buf).unwrap()
+        };
+        let mut yaml_str = String::new();
+        file.read_to_string(&mut yaml_str).unwrap();
+        let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
+        let doc = &docs[0];
+
+        // Load test cases
+        let test_cases = doc["test_cases"].clone();
+
+        for test_case in test_cases {
+            // Only the valid cases are checked as parse::<uX>() will fail for all invalid cases
+            if test_case["valid"].as_bool().unwrap() {
+                // Convert test vector 'ssz' encoded yaml to Vec<u8>
+                let ssz = test_case["ssz"].as_str().unwrap().trim_start_matches("0x");
+                let test_vector_bytes = hex::decode(ssz).unwrap();
+
+                // Convert test vector 'value' to ssz encoded bytes
+                let mut bytes: Vec<u8>;
+                match test_case["type"].as_str().unwrap() {
+                    "uint8" => {
+                        let value: u8 = test_case["value"].as_str().unwrap().parse::<u8>().unwrap();
+                        bytes = ssz_encode::<u8>(&value); // check encoding
+
+                        // Check decoding
+                        let decoded = decode::<u8>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    "uint16" => {
+                        let value: u16 =
+                            test_case["value"].as_str().unwrap().parse::<u16>().unwrap();
+                        bytes = ssz_encode::<u16>(&value);
+
+                        // Check decoding
+                        let decoded = decode::<u16>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    "uint32" => {
+                        let value: u32 =
+                            test_case["value"].as_str().unwrap().parse::<u32>().unwrap();
+                        bytes = ssz_encode::<u32>(&value);
+
+                        // Check decoding
+                        let decoded = decode::<u32>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    "uint64" => {
+                        let value: u64 =
+                            test_case["value"].as_str().unwrap().parse::<u64>().unwrap();
+                        bytes = ssz_encode::<u64>(&value);
+
+                        // Check decoding
+                        let decoded = decode::<u64>(&test_vector_bytes).unwrap();
+                        assert_eq!(decoded, value);
+                    }
+                    _ => continue,
+                };
+                assert_eq!(test_vector_bytes, bytes);
+            }
+        }
+    }
+
+    #[test]
+    pub fn test_vector_uint_wrong_length() {
+        let mut file = {
+            let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            file_path_buf.push("src/test_vectors/uint_wrong_length.yaml");
+
+            File::open(file_path_buf).unwrap()
+        };
+        let mut yaml_str = String::new();
+        file.read_to_string(&mut yaml_str).unwrap();
+        let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
+        let doc = &docs[0];
+
+        // Load test cases
+        let test_cases = doc["test_cases"].clone();
+
+        for test_case in test_cases {
+            // Convert test vector 'ssz' encoded yaml to Vec<u8>
+            let ssz = test_case["ssz"].as_str().unwrap().trim_start_matches("0x");
+            let test_vector_bytes = hex::decode(ssz).unwrap();
+
+            // Attempt to decode invalid ssz bytes
+            match test_case["type"].as_str().unwrap() {
+                "uint8" => {
+                    let decoded = decode::<u8>(&test_vector_bytes);
+                    assert!(decoded.is_err());
+                }
+                "uint16" => {
+                    let decoded = decode::<u16>(&test_vector_bytes);
+                    assert!(decoded.is_err());
+                }
+                "uint32" => {
+                    let decoded = decode::<u32>(&test_vector_bytes);
+                    assert!(decoded.is_err());
+                }
+                "uint64" => {
+                    let decoded = decode::<u64>(&test_vector_bytes);
+                    assert!(decoded.is_err());
+                }
+                _ => continue,
+            };
+        }
+    }
+}