Rename beacon_chain/ -> eth2/

eth2/utils/ssz/src/decode.rs

@@ -0,0 +1,193 @@
+use super::LENGTH_BYTES;
+
+#[derive(Debug, PartialEq)]
+pub enum DecodeError {
+    TooShort,
+    TooLong,
+    Invalid,
+}
+
+pub trait Decodable: Sized {
+    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError>;
+}
+
+/// 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>
+where
+    T: Decodable,
+{
+    if index >= ssz_bytes.len() {
+        return Err(DecodeError::TooShort);
+    }
+    T::ssz_decode(ssz_bytes, index)
+}
+
+/// Decode a vector (list) of encoded bytes.
+///
+/// Each element in the list will be decoded and placed into the vector.
+pub fn decode_ssz_list<T>(ssz_bytes: &[u8], index: usize) -> Result<(Vec<T>, usize), DecodeError>
+where
+    T: Decodable,
+{
+    if index + LENGTH_BYTES > ssz_bytes.len() {
+        return Err(DecodeError::TooShort);
+    };
+
+    // get the length
+    let serialized_length = match decode_length(ssz_bytes, index, LENGTH_BYTES) {
+        Err(v) => return Err(v),
+        Ok(v) => v,
+    };
+
+    let final_len: usize = index + LENGTH_BYTES + serialized_length;
+
+    if final_len > ssz_bytes.len() {
+        return Err(DecodeError::TooShort);
+    };
+
+    let mut tmp_index = index + LENGTH_BYTES;
+    let mut res_vec: Vec<T> = Vec::new();
+
+    while tmp_index < final_len {
+        match T::ssz_decode(ssz_bytes, tmp_index) {
+            Err(v) => return Err(v),
+            Ok(v) => {
+                tmp_index = v.1;
+                res_vec.push(v.0);
+            }
+        };
+    }
+
+    Ok((res_vec, final_len))
+}
+
+/// Given some number of bytes, interpret the first four
+/// bytes as a 32-bit big-endian integer and return the
+/// result.
+pub fn decode_length(
+    bytes: &[u8],
+    index: usize,
+    length_bytes: usize,
+) -> Result<usize, DecodeError> {
+    if bytes.len() < index + length_bytes {
+        return Err(DecodeError::TooShort);
+    };
+    let mut len: usize = 0;
+    for (i, byte) in bytes
+        .iter()
+        .enumerate()
+        .take(index + length_bytes)
+        .skip(index)
+    {
+        let offset = (index + length_bytes - i - 1) * 8;
+        len |= (*byte as usize) << offset;
+    }
+    Ok(len)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::encode::encode_length;
+    use super::*;
+
+    #[test]
+    fn test_ssz_decode_length() {
+        let decoded = decode_length(&vec![0, 0, 0, 1], 0, LENGTH_BYTES);
+        assert_eq!(decoded.unwrap(), 1);
+
+        let decoded = decode_length(&vec![0, 0, 1, 0], 0, LENGTH_BYTES);
+        assert_eq!(decoded.unwrap(), 256);
+
+        let decoded = decode_length(&vec![0, 0, 1, 255], 0, LENGTH_BYTES);
+        assert_eq!(decoded.unwrap(), 511);
+
+        let decoded = decode_length(&vec![255, 255, 255, 255], 0, LENGTH_BYTES);
+        assert_eq!(decoded.unwrap(), 4294967295);
+    }
+
+    #[test]
+    fn test_encode_decode_length() {
+        let params: Vec<usize> = vec![
+            0,
+            1,
+            2,
+            3,
+            7,
+            8,
+            16,
+            2 ^ 8,
+            2 ^ 8 + 1,
+            2 ^ 16,
+            2 ^ 16 + 1,
+            2 ^ 24,
+            2 ^ 24 + 1,
+            2 ^ 32,
+        ];
+        for i in params {
+            let decoded = decode_length(&encode_length(i, LENGTH_BYTES), 0, LENGTH_BYTES).unwrap();
+            assert_eq!(i, decoded);
+        }
+    }
+
+    #[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();
+
+        assert_eq!(decoded.0, v);
+        assert_eq!(decoded.1, 12);
+
+        // 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,
+            ],
+            0,
+        )
+        .unwrap();
+        assert_eq!(decoded.0, v);
+        assert_eq!(decoded.1, 20);
+
+        // u64
+        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,
+            ],
+            0,
+        )
+        .unwrap();
+        assert_eq!(decoded.0, v);
+        assert_eq!(decoded.1, 36);
+
+        // Check that it can accept index
+        let v: Vec<usize> = vec![15, 15, 15, 15];
+        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,
+            ],
+            10,
+        )
+        .unwrap();
+        assert_eq!(decoded.0, v);
+        assert_eq!(decoded.1, 46);
+
+        // 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);
+        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);
+        assert_eq!(decoded, Err(DecodeError::TooShort));
+    }
+}

eth2/utils/ssz/src/encode.rs

@@ -0,0 +1,124 @@
+use super::LENGTH_BYTES;
+
+pub trait Encodable {
+    fn ssz_append(&self, s: &mut SszStream);
+}
+
+/// Provides a buffer for appending ssz-encodable values.
+///
+/// Use the `append()` fn to add a value to a list, then use
+/// the `drain()` method to consume the struct and return the
+/// ssz encoded bytes.
+#[derive(Default)]
+pub struct SszStream {
+    buffer: Vec<u8>,
+}
+
+impl SszStream {
+    /// Create a new, empty stream for writing ssz values.
+    pub fn new() -> Self {
+        SszStream { buffer: Vec::new() }
+    }
+
+    /// Append some ssz encodable value to the stream.
+    pub fn append<E>(&mut self, value: &E) -> &mut Self
+    where
+        E: Encodable,
+    {
+        value.ssz_append(self);
+        self
+    }
+
+    /// Append some ssz encoded bytes to the stream.
+    ///
+    /// The length of the supplied bytes will be concatenated
+    /// to the stream before the supplied bytes.
+    pub fn append_encoded_val(&mut self, vec: &[u8]) {
+        self.buffer
+            .extend_from_slice(&encode_length(vec.len(), LENGTH_BYTES));
+        self.buffer.extend_from_slice(&vec);
+    }
+
+    /// Append some ssz encoded bytes to the stream without calculating length
+    ///
+    /// The raw bytes will be concatenated to the stream.
+    pub fn append_encoded_raw(&mut self, vec: &[u8]) {
+        self.buffer.extend_from_slice(&vec);
+    }
+
+    /// Append some vector (list) of encodable values to the stream.
+    ///
+    /// The length of the list will be concatenated to the stream, then
+    /// each item in the vector will be encoded and concatenated.
+    pub fn append_vec<E>(&mut self, vec: &[E])
+    where
+        E: Encodable,
+    {
+        let mut list_stream = SszStream::new();
+        for item in vec {
+            item.ssz_append(&mut list_stream);
+        }
+        self.append_encoded_val(&list_stream.drain());
+    }
+
+    /// Consume the stream and return the underlying bytes.
+    pub fn drain(self) -> Vec<u8> {
+        self.buffer
+    }
+}
+
+/// 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.
+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;
+        *header_byte = ((len >> offset) & 0xff) as u8;
+    }
+    header
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn test_encode_length_0_bytes_panic() {
+        encode_length(0, 0);
+    }
+
+    #[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(4294967295, LENGTH_BYTES), // 2^(3*8) - 1
+            vec![255, 255, 255, 255]
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_encode_length_4_bytes_panic() {
+        encode_length(4294967296, LENGTH_BYTES); // 2^(3*8)
+    }
+
+    #[test]
+    fn test_encode_list() {
+        let test_vec: Vec<u16> = vec![256; 12];
+        let mut stream = SszStream::new();
+        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]);
+    }
+}

eth2/utils/ssz/src/impl_decode.rs

@@ -0,0 +1,218 @@
+use super::decode::decode_ssz_list;
+use super::ethereum_types::{Address, H256};
+use super::{Decodable, DecodeError};
+
+macro_rules! impl_decodable_for_uint {
+    ($type: ident, $bit_size: expr) => {
+        impl Decodable for $type {
+            fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
+                assert!((0 < $bit_size) & ($bit_size <= 64) & ($bit_size % 8 == 0));
+                let max_bytes = $bit_size / 8;
+                if bytes.len() >= (index + max_bytes) {
+                    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;
+                        result |= ($type::from(*byte)) << offset;
+                    }
+                    Ok((result, end_bytes))
+                } else {
+                    Err(DecodeError::TooShort)
+                }
+            }
+        }
+    };
+}
+
+impl_decodable_for_uint!(u16, 16);
+impl_decodable_for_uint!(u32, 32);
+impl_decodable_for_uint!(u64, 64);
+impl_decodable_for_uint!(usize, 64);
+
+impl Decodable for u8 {
+    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
+        if index >= bytes.len() {
+            Err(DecodeError::TooShort)
+        } else {
+            Ok((bytes[index], index + 1))
+        }
+    }
+}
+
+impl Decodable for H256 {
+    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
+        if bytes.len() < 32 || bytes.len() - 32 < index {
+            Err(DecodeError::TooShort)
+        } else {
+            Ok((H256::from(&bytes[index..(index + 32)]), index + 32))
+        }
+    }
+}
+
+impl Decodable for Address {
+    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
+        if bytes.len() < 20 || bytes.len() - 20 < index {
+            Err(DecodeError::TooShort)
+        } else {
+            Ok((Address::from(&bytes[index..(index + 20)]), index + 20))
+        }
+    }
+}
+
+impl<T> Decodable for Vec<T>
+where
+    T: Decodable,
+{
+    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
+        decode_ssz_list(bytes, index)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::{decode_ssz, DecodeError};
+    use super::*;
+
+    #[test]
+    fn test_ssz_decode_h256() {
+        /*
+         * Input is exact length
+         */
+        let input = vec![42_u8; 32];
+        let (decoded, i) = H256::ssz_decode(&input, 0).unwrap();
+        assert_eq!(decoded.to_vec(), input);
+        assert_eq!(i, 32);
+
+        /*
+         * Input is too long
+         */
+        let mut input = vec![42_u8; 32];
+        input.push(12);
+        let (decoded, i) = H256::ssz_decode(&input, 0).unwrap();
+        assert_eq!(decoded.to_vec()[..], input[0..32]);
+        assert_eq!(i, 32);
+
+        /*
+         * Input is too short
+         */
+        let input = vec![42_u8; 31];
+        let res = H256::ssz_decode(&input, 0);
+        assert_eq!(res, Err(DecodeError::TooShort));
+    }
+
+    #[test]
+    fn test_ssz_decode_u16() {
+        let ssz = vec![0, 0];
+
+        let (result, index): (u16, usize) = decode_ssz(&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();
+        assert_eq!(result, 16);
+        assert_eq!(index, 2);
+
+        let ssz = vec![1, 0];
+        let (result, index): (u16, usize) = decode_ssz(&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();
+        assert_eq!(index, 2);
+        assert_eq!(result, 65535);
+
+        let ssz = vec![1];
+        let result: Result<(u16, usize), DecodeError> = decode_ssz(&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();
+        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();
+        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();
+        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();
+        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();
+        assert_eq!(index, 4);
+        assert_eq!(result, 4294967295);
+
+        let ssz = vec![0, 0, 1];
+        let result: Result<(u32, usize), DecodeError> = decode_ssz(&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();
+        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();
+        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();
+        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);
+        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();
+        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();
+        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();
+        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);
+        assert_eq!(result, Err(DecodeError::TooShort));
+    }
+
+    #[test]
+    fn test_decode_ssz_bounds() {
+        let err: Result<(u16, usize), DecodeError> = decode_ssz(&vec![1], 2);
+        assert_eq!(err, Err(DecodeError::TooShort));
+
+        let err: Result<(u16, usize), DecodeError> = decode_ssz(&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;
+        assert_eq!(result, 1);
+    }
+}

eth2/utils/ssz/src/impl_encode.rs

@@ -0,0 +1,201 @@
+extern crate bytes;
+
+use self::bytes::{BufMut, BytesMut};
+use super::ethereum_types::{Address, H256};
+use super::{Encodable, SszStream};
+
+/*
+ * Note: there is a "to_bytes" function for integers
+ * in Rust nightly. When it is in stable, we should
+ * use it instead.
+ */
+macro_rules! impl_encodable_for_uint {
+    ($type: ident, $bit_size: expr) => {
+        impl Encodable for $type {
+            #[allow(clippy::cast_lossless)]
+            fn ssz_append(&self, s: &mut SszStream) {
+                // Ensure bit size is valid
+                assert!(
+                    (0 < $bit_size)
+                        && ($bit_size % 8 == 0)
+                        && (2_u128.pow($bit_size) > *self as u128)
+                );
+
+                // Serialize to bytes
+                let mut buf = BytesMut::with_capacity($bit_size / 8);
+
+                // 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),
+                    _ => {}
+                }
+
+                // Append bytes to the SszStream
+                s.append_encoded_raw(&buf.to_vec());
+            }
+        }
+    };
+}
+
+impl_encodable_for_uint!(u8, 8);
+impl_encodable_for_uint!(u16, 16);
+impl_encodable_for_uint!(u32, 32);
+impl_encodable_for_uint!(u64, 64);
+impl_encodable_for_uint!(usize, 64);
+
+impl Encodable for H256 {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append_encoded_raw(&self.to_vec());
+    }
+}
+
+impl Encodable for Address {
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append_encoded_raw(&self.to_vec());
+    }
+}
+
+impl<T> Encodable for Vec<T>
+where
+    T: Encodable,
+{
+    fn ssz_append(&self, s: &mut SszStream) {
+        s.append_vec(&self);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ssz_encode_h256() {
+        let h = H256::zero();
+        let mut ssz = SszStream::new();
+        ssz.append(&h);
+        assert_eq!(ssz.drain(), vec![0; 32]);
+    }
+
+    #[test]
+    fn test_ssz_encode_u8() {
+        let x: u8 = 0;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0]);
+
+        let x: u8 = 1;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![1]);
+
+        let x: u8 = 100;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![100]);
+
+        let x: u8 = 255;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![255]);
+    }
+
+    #[test]
+    fn test_ssz_encode_u16() {
+        let x: u16 = 1;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0, 1]);
+
+        let x: u16 = 100;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0, 100]);
+
+        let x: u16 = 1 << 8;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![1, 0]);
+
+        let x: u16 = 65535;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![255, 255]);
+    }
+
+    #[test]
+    fn test_ssz_encode_u32() {
+        let x: u32 = 1;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0, 0, 0, 1]);
+
+        let x: u32 = 100;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0, 0, 0, 100]);
+
+        let x: u32 = 1 << 16;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0, 1, 0, 0]);
+
+        let x: u32 = 1 << 24;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![1, 0, 0, 0]);
+
+        let x: u32 = !0;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![255, 255, 255, 255]);
+    }
+
+    #[test]
+    fn test_ssz_encode_u64() {
+        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]);
+
+        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]);
+
+        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]);
+
+        let x: u64 = !0;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![255, 255, 255, 255, 255, 255, 255, 255]);
+    }
+
+    #[test]
+    fn test_ssz_encode_usize() {
+        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]);
+
+        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]);
+
+        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]);
+
+        let x: usize = !0;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![255, 255, 255, 255, 255, 255, 255, 255]);
+    }
+}

eth2/utils/ssz/src/lib.rs

@@ -0,0 +1,33 @@
+/*
+ * This is a WIP of implementing an alternative
+ * serialization strategy. It attempts to follow Vitalik's
+ * "simpleserialize" format here:
+ * https://github.com/ethereum/beacon_chain/blob/master/beacon_chain/utils/simpleserialize.py
+ *
+ * This implementation is not final and would almost certainly
+ * have issues.
+ */
+extern crate bytes;
+extern crate ethereum_types;
+
+pub mod decode;
+pub mod encode;
+
+mod impl_decode;
+mod impl_encode;
+
+pub use crate::decode::{decode_ssz, decode_ssz_list, Decodable, DecodeError};
+pub use crate::encode::{Encodable, SszStream};
+
+pub const LENGTH_BYTES: usize = 4;
+pub const MAX_LIST_SIZE: usize = 1 << (4 * 8);
+
+/// Convenience function to SSZ encode an object supporting ssz::Encode.
+pub fn ssz_encode<T>(val: &T) -> Vec<u8>
+where
+    T: Encodable,
+{
+    let mut ssz_stream = SszStream::new();
+    ssz_stream.append(val);
+    ssz_stream.drain()
+}