Rename SSZ traits (Encodable -> Encode)

beacon_node/db/src/stores/beacon_block_store.rs

@@ -1,6 +1,6 @@
 use super::BLOCKS_DB_COLUMN as DB_COLUMN;
 use super::{ClientDB, DBError};
-use ssz::Decodable;
+use ssz::Decode;
 use std::sync::Arc;
 use types::{BeaconBlock, Hash256, Slot};
 

beacon_node/db/src/stores/beacon_state_store.rs

@@ -1,6 +1,6 @@
 use super::STATES_DB_COLUMN as DB_COLUMN;
 use super::{ClientDB, DBError};
-use ssz::Decodable;
+use ssz::Decode;
 use std::sync::Arc;
 use types::{BeaconState, EthSpec, Hash256};
 

beacon_node/db/src/stores/validator_store.rs

@@ -4,7 +4,7 @@ use self::bytes::{BufMut, BytesMut};
 use super::VALIDATOR_DB_COLUMN as DB_COLUMN;
 use super::{ClientDB, DBError};
 use bls::PublicKey;
-use ssz::{Decodable, Encodable};
+use ssz::{Decode, Encode};
 use std::sync::Arc;
 
 #[derive(Debug, PartialEq)]

beacon_node/eth2-libp2p/src/behaviour.rs

@@ -13,7 +13,7 @@ use libp2p::{
     NetworkBehaviour, PeerId,
 };
 use slog::{debug, o, trace, warn};
-use ssz::{ssz_encode, Decodable, DecodeError, Encodable};
+use ssz::{ssz_encode, Decode, DecodeError, Encode};
 use types::{Attestation, BeaconBlock};
 use types::{Topic, TopicHash};
 
@@ -197,13 +197,13 @@ pub enum PubsubMessage {
 }
 
 //TODO: Correctly encode/decode enums. Prefixing with integer for now.
-impl Encodable for PubsubMessage {
+impl Encode for PubsubMessage {
     fn is_ssz_fixed_len() -> bool {
         false
     }
 
     fn ssz_append(&self, buf: &mut Vec<u8>) {
-        let offset = <u32 as Encodable>::ssz_fixed_len() + <Vec<u8> as Encodable>::ssz_fixed_len();
+        let offset = <u32 as Encode>::ssz_fixed_len() + <Vec<u8> as Encode>::ssz_fixed_len();
 
         let mut encoder = ssz::SszEncoder::container(buf, offset);
 
@@ -226,7 +226,7 @@ impl Encodable for PubsubMessage {
     }
 }
 
-impl Decodable for PubsubMessage {
+impl Decode for PubsubMessage {
     fn is_ssz_fixed_len() -> bool {
         false
     }

beacon_node/eth2-libp2p/src/rpc/protocol.rs

@@ -1,6 +1,6 @@
 use super::methods::*;
 use libp2p::core::{upgrade, InboundUpgrade, OutboundUpgrade, UpgradeInfo};
-use ssz::{impl_decode_via_from, impl_encode_via_from, ssz_encode, Decodable, Encodable};
+use ssz::{impl_decode_via_from, impl_encode_via_from, ssz_encode, Decode, Encode};
 use std::hash::{Hash, Hasher};
 use std::io;
 use std::iter;
@@ -203,7 +203,7 @@ where
     }
 }
 
-impl Encodable for RPCEvent {
+impl Encode for RPCEvent {
     fn is_ssz_fixed_len() -> bool {
         false
     }
@@ -213,9 +213,9 @@ impl Encodable for RPCEvent {
     // This code has not been tested, it is a placeholder until we can update to the new libp2p
     // spec.
     fn ssz_append(&self, buf: &mut Vec<u8>) {
-        let offset = <bool as Encodable>::ssz_fixed_len()
+        let offset = <bool as Encode>::ssz_fixed_len()
-            + <u16 as Encodable>::ssz_fixed_len()
+            + <u16 as Encode>::ssz_fixed_len()
-            + <Vec<u8> as Encodable>::ssz_fixed_len();
+            + <Vec<u8> as Encode>::ssz_fixed_len();
 
         let mut encoder = ssz::SszEncoder::container(buf, offset);
 

beacon_node/rpc/src/attestation.rs

@@ -7,7 +7,7 @@ use protos::services::{
 };
 use protos::services_grpc::AttestationService;
 use slog::{error, info, trace, warn};
-use ssz::{ssz_encode, Decodable};
+use ssz::{ssz_encode, Decode};
 use std::sync::Arc;
 use types::{Attestation, EthSpec};
 

beacon_node/rpc/src/beacon_block.rs

@@ -11,7 +11,7 @@ use protos::services::{
 use protos::services_grpc::BeaconBlockService;
 use slog::Logger;
 use slog::{error, info, trace, warn};
-use ssz::{ssz_encode, Decodable};
+use ssz::{ssz_encode, Decode};
 use std::sync::Arc;
 use types::{BeaconBlock, EthSpec, Signature, Slot};
 

beacon_node/rpc/src/validator.rs

@@ -5,7 +5,7 @@ use grpcio::{RpcContext, RpcStatus, RpcStatusCode, UnarySink};
 use protos::services::{ActiveValidator, GetDutiesRequest, GetDutiesResponse, ValidatorDuty};
 use protos::services_grpc::ValidatorService;
 use slog::{trace, warn};
-use ssz::Decodable;
+use ssz::Decode;
 use std::sync::Arc;
 use types::{Epoch, EthSpec, RelativeEpoch};
 

eth2/README.md

@@ -30,7 +30,7 @@ Rust crates containing logic common across the Lighthouse project.
 	- [`ssz`](utils/ssz/): an implementation of the SimpleSerialize 
 	    serialization/deserialization protocol used by Eth 2.0.
 	- [`ssz_derive`](utils/ssz_derive/): provides procedural macros for
-		deriving SSZ `Encodable`, `Decodable`, and `TreeHash` methods.
+		deriving SSZ `Encode`, `Decode`, and `TreeHash` methods.
 	- [`swap_or_not_shuffle`](utils/swap_or_not_shuffle/): a list-shuffling
 		method which is slow, but allows for a subset of indices to be shuffled.
 	- [`test_random_derive`](utils/test_random_derive/): provides procedural

eth2/types/src/slot_epoch.rs

@@ -15,7 +15,7 @@ use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::{Deserialize, Serialize};
 use slog;
-use ssz::{ssz_encode, Decodable, DecodeError, Encodable};
+use ssz::{ssz_encode, Decode, DecodeError, Encode};
 use std::cmp::{Ord, Ordering};
 use std::fmt;
 use std::hash::{Hash, Hasher};

eth2/types/src/slot_epoch_macros.rs

@@ -192,13 +192,13 @@ macro_rules! impl_display {
 
 macro_rules! impl_ssz {
     ($type: ident) => {
-        impl Encodable for $type {
+        impl Encode for $type {
             fn is_ssz_fixed_len() -> bool {
-                <u64 as Encodable>::is_ssz_fixed_len()
+                <u64 as Encode>::is_ssz_fixed_len()
             }
 
             fn ssz_fixed_len() -> usize {
-                <u64 as Encodable>::ssz_fixed_len()
+                <u64 as Encode>::ssz_fixed_len()
             }
 
             fn ssz_append(&self, buf: &mut Vec<u8>) {
@@ -206,13 +206,13 @@ macro_rules! impl_ssz {
             }
         }
 
-        impl Decodable for $type {
+        impl Decode for $type {
             fn is_ssz_fixed_len() -> bool {
-                <u64 as Decodable>::is_ssz_fixed_len()
+                <u64 as Decode>::is_ssz_fixed_len()
             }
 
             fn ssz_fixed_len() -> usize {
-                <u64 as Decodable>::ssz_fixed_len()
+                <u64 as Decode>::ssz_fixed_len()
             }
 
             fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {

eth2/types/src/slot_height.rs

@@ -3,7 +3,7 @@ use crate::test_utils::TestRandom;
 
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{ssz_encode, Decodable, DecodeError, Encodable};
+use ssz::{ssz_encode, Decode, DecodeError, Encode};
 use std::cmp::{Ord, Ordering};
 use std::fmt;
 use std::hash::{Hash, Hasher};

eth2/types/src/test_utils/macros.rs

@@ -5,7 +5,7 @@ macro_rules! ssz_tests {
         #[test]
         pub fn test_ssz_round_trip() {
             use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-            use ssz::{ssz_encode, Decodable};
+            use ssz::{ssz_encode, Decode};
 
             let mut rng = XorShiftRng::from_seed([42; 16]);
             let original = $type::random_for_test(&mut rng);

eth2/types/src/tree_hash_vector.rs

@@ -1,7 +1,7 @@
 use crate::test_utils::{RngCore, TestRandom};
 use cached_tree_hash::CachedTreeHash;
 use serde_derive::{Deserialize, Serialize};
-use ssz::{Decodable, DecodeError, Encodable};
+use ssz::{Decode, DecodeError, Encode};
 use std::ops::{Deref, DerefMut};
 use tree_hash::TreeHash;
 
@@ -82,18 +82,18 @@ where
     }
 }
 
-impl<T> Encodable for TreeHashVector<T>
+impl<T> Encode for TreeHashVector<T>
 where
-    T: Encodable,
+    T: Encode,
 {
     fn ssz_append(&self, s: &mut SszStream) {
         s.append_vec(self)
     }
 }
 
-impl<T> Decodable for TreeHashVector<T>
+impl<T> Decode for TreeHashVector<T>
 where
-    T: Decodable,
+    T: Decode,
 {
     fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
         ssz::decode_ssz_list(bytes, index).and_then(|(vec, i)| Ok((vec.into(), i)))

eth2/utils/bls/src/aggregate_signature.rs

@@ -6,7 +6,7 @@ use cached_tree_hash::cached_tree_hash_ssz_encoding_as_vector;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::{encode as hex_encode, HexVisitor};
-use ssz::{Decodable, DecodeError};
+use ssz::{Decode, DecodeError};
 use tree_hash::tree_hash_ssz_encoding_as_vector;
 
 /// A BLS aggregate signature.
@@ -168,7 +168,7 @@ cached_tree_hash_ssz_encoding_as_vector!(AggregateSignature, 96);
 mod tests {
     use super::super::{Keypair, Signature};
     use super::*;
-    use ssz::Encodable;
+    use ssz::Encode;
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/utils/bls/src/fake_aggregate_signature.rs

@@ -3,7 +3,7 @@ use cached_tree_hash::cached_tree_hash_ssz_encoding_as_vector;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::{encode as hex_encode, PrefixedHexVisitor};
-use ssz::{ssz_encode, Decodable, DecodeError};
+use ssz::{ssz_encode, Decode, DecodeError};
 use tree_hash::tree_hash_ssz_encoding_as_vector;
 
 /// A BLS aggregate signature.

eth2/utils/bls/src/fake_signature.rs

@@ -4,7 +4,7 @@ use hex::encode as hex_encode;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::HexVisitor;
-use ssz::{ssz_encode, Decodable, DecodeError};
+use ssz::{ssz_encode, Decode, DecodeError};
 use tree_hash::tree_hash_ssz_encoding_as_vector;
 
 /// A single BLS signature.

eth2/utils/bls/src/macros.rs

@@ -1,6 +1,6 @@
 macro_rules! impl_ssz {
     ($type: ident, $byte_size: expr, $item_str: expr) => {
-        impl ssz::Encodable for $type {
+        impl ssz::Encode for $type {
             fn is_ssz_fixed_len() -> bool {
                 true
             }
@@ -14,7 +14,7 @@ macro_rules! impl_ssz {
             }
         }
 
-        impl ssz::Decodable for $type {
+        impl ssz::Decode for $type {
             fn is_ssz_fixed_len() -> bool {
                 true
             }
@@ -25,7 +25,7 @@ macro_rules! impl_ssz {
 
             fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
                 let len = bytes.len();
-                let expected = <Self as ssz::Decodable>::ssz_fixed_len();
+                let expected = <Self as ssz::Decode>::ssz_fixed_len();
 
                 if len != expected {
                     Err(ssz::DecodeError::InvalidByteLength { len, expected })

eth2/utils/bls/src/public_key.rs

@@ -4,7 +4,7 @@ use cached_tree_hash::cached_tree_hash_ssz_encoding_as_vector;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::{encode as hex_encode, HexVisitor};
-use ssz::{ssz_encode, Decodable, DecodeError};
+use ssz::{ssz_encode, Decode, DecodeError};
 use std::default;
 use std::fmt;
 use std::hash::{Hash, Hasher};

eth2/utils/bls/src/secret_key.rs

@@ -4,7 +4,7 @@ use hex::encode as hex_encode;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::HexVisitor;
-use ssz::{ssz_encode, Decodable, DecodeError};
+use ssz::{ssz_encode, Decode, DecodeError};
 use tree_hash::tree_hash_ssz_encoding_as_vector;
 
 /// A single BLS signature.

eth2/utils/bls/src/signature.rs

@@ -5,7 +5,7 @@ use hex::encode as hex_encode;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::HexVisitor;
-use ssz::{ssz_encode, Decodable, DecodeError};
+use ssz::{ssz_encode, Decode, DecodeError};
 use tree_hash::tree_hash_ssz_encoding_as_vector;
 
 /// A single BLS signature.

eth2/utils/boolean-bitfield/src/lib.rs

@@ -7,7 +7,7 @@ use cached_tree_hash::cached_tree_hash_bytes_as_list;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use serde_hex::{encode, PrefixedHexVisitor};
-use ssz::{Decodable, Encodable};
+use ssz::{Decode, Encode};
 use std::cmp;
 use std::default;
 
@@ -194,7 +194,7 @@ impl std::ops::BitOr for BooleanBitfield {
     }
 }
 
-impl Encodable for BooleanBitfield {
+impl Encode for BooleanBitfield {
     fn is_ssz_fixed_len() -> bool {
         false
     }
@@ -204,7 +204,7 @@ impl Encodable for BooleanBitfield {
     }
 }
 
-impl Decodable for BooleanBitfield {
+impl Decode for BooleanBitfield {
     fn is_ssz_fixed_len() -> bool {
         false
     }

eth2/utils/fixed_len_vec/src/impls.rs

@@ -1,6 +1,6 @@
 use super::*;
 // use cached_tree_hash::CachedTreeHash;
-// use ssz::{Decodable, Encodable};
+// use ssz::{Decode, Encode};
 // use tree_hash::TreeHash;
 
 impl<T, N: Unsigned> tree_hash::TreeHash for FixedLenVec<T, N>
@@ -51,16 +51,16 @@ where
     }
 }
 
-impl<T, N: Unsigned> ssz::Encodable for FixedLenVec<T, N>
+impl<T, N: Unsigned> ssz::Encode for FixedLenVec<T, N>
 where
-    T: ssz::Encodable,
+    T: ssz::Encode,
 {
     fn is_ssz_fixed_len() -> bool {
         true
     }
 
     fn ssz_fixed_len() -> usize {
-        if <Self as ssz::Encodable>::is_ssz_fixed_len() {
+        if <Self as ssz::Encode>::is_ssz_fixed_len() {
             T::ssz_fixed_len() * N::to_usize()
         } else {
             ssz::BYTES_PER_LENGTH_OFFSET
@@ -86,16 +86,16 @@ where
     }
 }
 
-impl<T, N: Unsigned> ssz::Decodable for FixedLenVec<T, N>
+impl<T, N: Unsigned> ssz::Decode for FixedLenVec<T, N>
 where
-    T: ssz::Decodable + Default,
+    T: ssz::Decode + Default,
 {
     fn is_ssz_fixed_len() -> bool {
         T::is_ssz_fixed_len()
     }
 
     fn ssz_fixed_len() -> usize {
-        if <Self as ssz::Decodable>::is_ssz_fixed_len() {
+        if <Self as ssz::Decode>::is_ssz_fixed_len() {
             T::ssz_fixed_len() * N::to_usize()
         } else {
             ssz::BYTES_PER_LENGTH_OFFSET
@@ -127,10 +127,10 @@ mod ssz_tests {
     fn encode() {
         let vec: FixedLenVec<u16, U2> = vec![0; 2].into();
         assert_eq!(vec.as_ssz_bytes(), vec![0, 0, 0, 0]);
-        assert_eq!(<FixedLenVec<u16, U2> as Encodable>::ssz_fixed_len(), 4);
+        assert_eq!(<FixedLenVec<u16, U2> as Encode>::ssz_fixed_len(), 4);
     }
 
-    fn round_trip<T: Encodable + Decodable + std::fmt::Debug + PartialEq>(item: T) {
+    fn round_trip<T: Encode + Decode + std::fmt::Debug + PartialEq>(item: T) {
         let encoded = &item.as_ssz_bytes();
         assert_eq!(T::from_ssz_bytes(&encoded), Ok(item));
     }

eth2/utils/ssz/README.md

@@ -38,8 +38,8 @@ spec is decided.*\
   + [bytes v0.4.9](#bytes-v049)
   + [ethereum-types](#ethereum-types)
 * [Interface](#interface)
-  + [Encodable](#encodable)
+  + [Encode](#encodable)
-  + [Decodable](#decodable)
+  + [Decode](#decodable)
   + [SszStream](#sszstream)
     - [new()](#new)
     - [append(&mut self, value: &E) -> &mut Self](#appendmut-self-value-e---mut-self)
@@ -299,24 +299,24 @@ Github: [ https://github.com/paritytech/primitives ](https://github.com/parityte
 
 ## Interface
 
-### Encodable
+### Encode
 
-A type is **Encodable** if it has a valid ``ssz_append`` function. This is
+A type is **Encode** if it has a valid ``ssz_append`` function. This is
 used to ensure that the object/type can be serialized.
 
 ```rust
-pub trait Encodable {
+pub trait Encode {
     fn ssz_append(&self, s: &mut SszStream);
 }
 ```
 
-### Decodable
+### Decode
 
-A type is **Decodable** if it has a valid ``ssz_decode`` function. This is
+A type is **Decode** if it has a valid ``ssz_decode`` function. This is
 used to ensure the object is deserializable.
 
 ```rust
-pub trait Decodable: Sized {
+pub trait Decode: Sized {
     fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError>;
 }
 ```
@@ -342,7 +342,7 @@ Appends a value that can be encoded into the stream.
 
 | Parameter | Description                              |
 |:---------:|:-----------------------------------------|
-| ``value`` | Encodable value to append to the stream. |
+| ``value`` | Encode value to append to the stream. |
 
 **Example**
 
@@ -371,7 +371,7 @@ Appends some vector (list) of encodable values to the stream.
 
 | Parameter | Description                                   |
 |:---------:|:----------------------------------------------|
-|  ``vec``  | Vector of Encodable objects to be serialized. |
+|  ``vec``  | Vector of Encode objects to be serialized. |
 
 **Example**
 

eth2/utils/ssz/benches/benches.rs

@@ -3,7 +3,7 @@ extern crate criterion;
 
 use criterion::black_box;
 use criterion::{Benchmark, Criterion};
-use ssz::{Decodable, Encodable};
+use ssz::{Decode, Encode};
 use ssz_derive::{Decode, Encode};
 
 #[derive(Clone, Copy, Encode, Decode)]

eth2/utils/ssz/examples/large_list.rs

@@ -2,7 +2,7 @@
 //!
 //! Useful for `cargo flamegraph`.
 
-use ssz::{Decodable, Encodable};
+use ssz::{Decode, Encode};
 
 fn main() {
     let vec: Vec<u64> = vec![4242; 8196];

eth2/utils/ssz/examples/large_list_of_structs.rs

@@ -2,7 +2,7 @@
 //!
 //! Useful for `cargo flamegraph`.
 
-use ssz::{Decodable, Encodable};
+use ssz::{Decode, Encode};
 use ssz_derive::{Decode, Encode};
 
 #[derive(Clone, Copy, Encode, Decode)]

eth2/utils/ssz/examples/struct_definition.rs

@@ -1,4 +1,4 @@
-use ssz::{Decodable, DecodeError, Encodable, SszDecoderBuilder, SszEncoder};
+use ssz::{Decode, DecodeError, Encode, SszDecoderBuilder, SszEncoder};
 
 #[derive(Debug, PartialEq)]
 pub struct Foo {
@@ -7,15 +7,15 @@ pub struct Foo {
     c: u16,
 }
 
-impl Encodable for Foo {
+impl Encode for Foo {
     fn is_ssz_fixed_len() -> bool {
-        <u16 as Encodable>::is_ssz_fixed_len() && <Vec<u16> as Encodable>::is_ssz_fixed_len()
+        <u16 as Encode>::is_ssz_fixed_len() && <Vec<u16> as Encode>::is_ssz_fixed_len()
     }
 
     fn ssz_append(&self, buf: &mut Vec<u8>) {
-        let offset = <u16 as Encodable>::ssz_fixed_len()
+        let offset = <u16 as Encode>::ssz_fixed_len()
-            + <Vec<u16> as Encodable>::ssz_fixed_len()
+            + <Vec<u16> as Encode>::ssz_fixed_len()
-            + <u16 as Encodable>::ssz_fixed_len();
+            + <u16 as Encode>::ssz_fixed_len();
 
         let mut encoder = SszEncoder::container(buf, offset);
 
@@ -27,9 +27,9 @@ impl Encodable for Foo {
     }
 }
 
-impl Decodable for Foo {
+impl Decode for Foo {
     fn is_ssz_fixed_len() -> bool {
-        <u16 as Decodable>::is_ssz_fixed_len() && <Vec<u16> as Decodable>::is_ssz_fixed_len()
+        <u16 as Decode>::is_ssz_fixed_len() && <Vec<u16> as Decode>::is_ssz_fixed_len()
     }
 
     fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {

eth2/utils/ssz/src/decode.rs

@@ -26,7 +26,7 @@ pub enum DecodeError {
 ///
 /// See `examples/` for manual implementations or the crate root for implementations using
 /// `#[derive(Decode)]`.
-pub trait Decodable: Sized {
+pub trait Decode: Sized {
     /// Returns `true` if this object has a fixed-length.
     ///
     /// I.e., there are no variable length items in this object or any of it's contained objects.
@@ -80,7 +80,7 @@ impl<'a> SszDecoderBuilder<'a> {
     }
 
     /// Declares that some type `T` is the next item in `bytes`.
-    pub fn register_type<T: Decodable>(&mut self) -> Result<(), DecodeError> {
+    pub fn register_type<T: Decode>(&mut self) -> Result<(), DecodeError> {
         if T::is_ssz_fixed_len() {
             let start = self.items_index;
             self.items_index += T::ssz_fixed_len();
@@ -173,7 +173,7 @@ impl<'a> SszDecoderBuilder<'a> {
 ///
 /// ```rust
 /// use ssz_derive::{Encode, Decode};
-/// use ssz::{Decodable, Encodable, SszDecoder, SszDecoderBuilder};
+/// use ssz::{Decode, Encode, SszDecoder, SszDecoderBuilder};
 ///
 /// #[derive(PartialEq, Debug, Encode, Decode)]
 /// struct Foo {
@@ -215,7 +215,7 @@ impl<'a> SszDecoder<'a> {
     /// # Panics
     ///
     /// Panics when attempting to decode more items than actually exist.
-    pub fn decode_next<T: Decodable>(&mut self) -> Result<T, DecodeError> {
+    pub fn decode_next<T: Decode>(&mut self) -> Result<T, DecodeError> {
         T::from_ssz_bytes(self.items.remove(0))
     }
 }

eth2/utils/ssz/src/decode/impls.rs

@@ -3,7 +3,7 @@ use ethereum_types::H256;
 
 macro_rules! impl_decodable_for_uint {
     ($type: ident, $bit_size: expr) => {
-        impl Decodable for $type {
+        impl Decode for $type {
             fn is_ssz_fixed_len() -> bool {
                 true
             }
@@ -14,7 +14,7 @@ macro_rules! impl_decodable_for_uint {
 
             fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
                 let len = bytes.len();
-                let expected = <Self as Decodable>::ssz_fixed_len();
+                let expected = <Self as Decode>::ssz_fixed_len();
 
                 if len != expected {
                     Err(DecodeError::InvalidByteLength { len, expected })
@@ -35,7 +35,7 @@ impl_decodable_for_uint!(u32, 32);
 impl_decodable_for_uint!(u64, 64);
 impl_decodable_for_uint!(usize, 64);
 
-impl Decodable for bool {
+impl Decode for bool {
     fn is_ssz_fixed_len() -> bool {
         true
     }
@@ -46,7 +46,7 @@ impl Decodable for bool {
 
     fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
         let len = bytes.len();
-        let expected = <Self as Decodable>::ssz_fixed_len();
+        let expected = <Self as Decode>::ssz_fixed_len();
 
         if len != expected {
             Err(DecodeError::InvalidByteLength { len, expected })
@@ -64,7 +64,7 @@ impl Decodable for bool {
     }
 }
 
-impl Decodable for H256 {
+impl Decode for H256 {
     fn is_ssz_fixed_len() -> bool {
         true
     }
@@ -75,7 +75,7 @@ impl Decodable for H256 {
 
     fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
         let len = bytes.len();
-        let expected = <Self as Decodable>::ssz_fixed_len();
+        let expected = <Self as Decode>::ssz_fixed_len();
 
         if len != expected {
             Err(DecodeError::InvalidByteLength { len, expected })
@@ -87,7 +87,7 @@ impl Decodable for H256 {
 
 macro_rules! impl_decodable_for_u8_array {
     ($len: expr) => {
-        impl Decodable for [u8; $len] {
+        impl Decode for [u8; $len] {
             fn is_ssz_fixed_len() -> bool {
                 true
             }
@@ -98,7 +98,7 @@ macro_rules! impl_decodable_for_u8_array {
 
             fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError> {
                 let len = bytes.len();
-                let expected = <Self as Decodable>::ssz_fixed_len();
+                let expected = <Self as Decode>::ssz_fixed_len();
 
                 if len != expected {
                     Err(DecodeError::InvalidByteLength { len, expected })
@@ -115,7 +115,7 @@ macro_rules! impl_decodable_for_u8_array {
 
 impl_decodable_for_u8_array!(4);
 
-impl<T: Decodable> Decodable for Vec<T> {
+impl<T: Decode> Decode for Vec<T> {
     fn is_ssz_fixed_len() -> bool {
         false
     }
@@ -139,7 +139,7 @@ impl<T: Decodable> Decodable for Vec<T> {
 /// The `ssz::SszDecoder` can also perform this functionality, however it it significantly faster
 /// as it is optimized to read same-typed items whilst `ssz::SszDecoder` supports reading items of
 /// differing types.
-pub fn decode_list_of_variable_length_items<T: Decodable>(
+pub fn decode_list_of_variable_length_items<T: Decode>(
     bytes: &[u8],
 ) -> Result<Vec<T>, DecodeError> {
     let mut next_variable_byte = read_offset(bytes)?;

eth2/utils/ssz/src/encode.rs

@@ -6,7 +6,7 @@ mod impls;
 ///
 /// See `examples/` for manual implementations or the crate root for implementations using
 /// `#[derive(Encode)]`.
-pub trait Encodable {
+pub trait Encode {
     /// Returns `true` if this object has a fixed-length.
     ///
     /// I.e., there are no variable length items in this object or any of it's contained objects.
@@ -50,7 +50,7 @@ pub trait Encodable {
 ///
 /// ```rust
 /// use ssz_derive::{Encode, Decode};
-/// use ssz::{Decodable, Encodable, SszEncoder};
+/// use ssz::{Decode, Encode, SszEncoder};
 ///
 /// #[derive(PartialEq, Debug, Encode, Decode)]
 /// struct Foo {
@@ -65,7 +65,7 @@ pub trait Encodable {
 ///     };
 ///
 ///     let mut buf: Vec<u8> = vec![];
-///     let offset = <u64 as Encodable>::ssz_fixed_len() + <Vec<u16> as Encodable>::ssz_fixed_len();
+///     let offset = <u64 as Encode>::ssz_fixed_len() + <Vec<u16> as Encode>::ssz_fixed_len();
 ///
 ///     let mut encoder = SszEncoder::container(&mut buf, offset);
 ///
@@ -104,7 +104,7 @@ impl<'a> SszEncoder<'a> {
     }
 
     /// Append some `item` to the SSZ bytes.
-    pub fn append<T: Encodable>(&mut self, item: &T) {
+    pub fn append<T: Encode>(&mut self, item: &T) {
         if T::is_ssz_fixed_len() {
             item.ssz_append(&mut self.buf);
         } else {

eth2/utils/ssz/src/encode/impls.rs

@@ -3,7 +3,7 @@ use ethereum_types::H256;
 
 macro_rules! impl_encodable_for_uint {
     ($type: ident, $bit_size: expr) => {
-        impl Encodable for $type {
+        impl Encode for $type {
             fn is_ssz_fixed_len() -> bool {
                 true
             }
@@ -25,7 +25,7 @@ impl_encodable_for_uint!(u32, 32);
 impl_encodable_for_uint!(u64, 64);
 impl_encodable_for_uint!(usize, 64);
 
-impl<T: Encodable> Encodable for Vec<T> {
+impl<T: Encode> Encode for Vec<T> {
     fn is_ssz_fixed_len() -> bool {
         false
     }
@@ -49,7 +49,7 @@ impl<T: Encodable> Encodable for Vec<T> {
     }
 }
 
-impl Encodable for bool {
+impl Encode for bool {
     fn is_ssz_fixed_len() -> bool {
         true
     }
@@ -63,7 +63,7 @@ impl Encodable for bool {
     }
 }
 
-impl Encodable for H256 {
+impl Encode for H256 {
     fn is_ssz_fixed_len() -> bool {
         true
     }
@@ -79,7 +79,7 @@ impl Encodable for H256 {
 
 macro_rules! impl_encodable_for_u8_array {
     ($len: expr) => {
-        impl Encodable for [u8; $len] {
+        impl Encode for [u8; $len] {
             fn is_ssz_fixed_len() -> bool {
                 true
             }

eth2/utils/ssz/src/lib.rs

@@ -9,7 +9,7 @@
 //!
 //! ```rust
 //! use ssz_derive::{Encode, Decode};
-//! use ssz::{Decodable, Encodable};
+//! use ssz::{Decode, Encode};
 //!
 //! #[derive(PartialEq, Debug, Encode, Decode)]
 //! struct Foo {
@@ -32,17 +32,16 @@
 //!
 //! ```
 //!
-//! See `examples/` for manual implementations of the `Encodable` and `Decodable` traits.
+//! See `examples/` for manual implementations of the `Encode` and `Decode` traits.
 
 mod decode;
 mod encode;
 mod macros;
 
 pub use decode::{
-    impls::decode_list_of_variable_length_items, Decodable, DecodeError, SszDecoder,
+    impls::decode_list_of_variable_length_items, Decode, DecodeError, SszDecoder, SszDecoderBuilder,
-    SszDecoderBuilder,
 };
-pub use encode::{Encodable, SszEncoder};
+pub use encode::{Encode, SszEncoder};
 
 /// The number of bytes used to represent an offset.
 pub const BYTES_PER_LENGTH_OFFSET: usize = 4;
@@ -54,7 +53,7 @@ pub const MAX_LENGTH_VALUE: usize = (1 << (BYTES_PER_LENGTH_OFFSET * 8)) - 1;
 /// Equivalent to `val.as_ssz_bytes()`.
 pub fn ssz_encode<T>(val: &T) -> Vec<u8>
 where
-    T: Encodable,
+    T: Encode,
 {
     val.as_ssz_bytes()
 }

eth2/utils/ssz/src/macros.rs

@@ -1,18 +1,18 @@
-/// Implements `Encodable` for `$impl_type` using an implementation of `From<$impl_type> for
+/// Implements `Encode` for `$impl_type` using an implementation of `From<$impl_type> for
 /// $from_type`.
 ///
-/// In effect, this allows for easy implementation of `Encodable` for some type that implements a
+/// In effect, this allows for easy implementation of `Encode` for some type that implements a
-/// `From` conversion into another type that already has `Encodable` implemented.
+/// `From` conversion into another type that already has `Encode` implemented.
 #[macro_export]
 macro_rules! impl_encode_via_from {
     ($impl_type: ty, $from_type: ty) => {
-        impl ssz::Encodable for $impl_type {
+        impl ssz::Encode for $impl_type {
             fn is_ssz_fixed_len() -> bool {
-                <$from_type as ssz::Encodable>::is_ssz_fixed_len()
+                <$from_type as ssz::Encode>::is_ssz_fixed_len()
             }
 
             fn ssz_fixed_len() -> usize {
-                <$from_type as ssz::Encodable>::ssz_fixed_len()
+                <$from_type as ssz::Encode>::ssz_fixed_len()
             }
 
             fn ssz_append(&self, buf: &mut Vec<u8>) {
@@ -24,21 +24,21 @@ macro_rules! impl_encode_via_from {
     };
 }
 
-/// Implements `Decodable` for `$impl_type` using an implementation of `From<$impl_type> for
+/// Implements `Decode` for `$impl_type` using an implementation of `From<$impl_type> for
 /// $from_type`.
 ///
-/// In effect, this allows for easy implementation of `Decodable` for some type that implements a
+/// In effect, this allows for easy implementation of `Decode` for some type that implements a
-/// `From` conversion into another type that already has `Decodable` implemented.
+/// `From` conversion into another type that already has `Decode` implemented.
 #[macro_export]
 macro_rules! impl_decode_via_from {
     ($impl_type: ty, $from_type: tt) => {
-        impl ssz::Decodable for $impl_type {
+        impl ssz::Decode for $impl_type {
             fn is_ssz_fixed_len() -> bool {
-                <$from_type as ssz::Decodable>::is_ssz_fixed_len()
+                <$from_type as ssz::Decode>::is_ssz_fixed_len()
             }
 
             fn ssz_fixed_len() -> usize {
-                <$from_type as ssz::Decodable>::ssz_fixed_len()
+                <$from_type as ssz::Decode>::ssz_fixed_len()
             }
 
             fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
@@ -51,7 +51,7 @@ macro_rules! impl_decode_via_from {
 #[cfg(test)]
 mod tests {
     use crate as ssz;
-    use ssz::{Decodable, Encodable};
+    use ssz::{Decode, Encode};
 
     #[derive(PartialEq, Debug, Clone, Copy)]
     struct Wrapper(u64);

eth2/utils/ssz/tests/tests.rs

@@ -1,11 +1,11 @@
 use ethereum_types::H256;
-use ssz::{Decodable, DecodeError, Encodable};
+use ssz::{Decode, DecodeError, Encode};
 use ssz_derive::{Decode, Encode};
 
 mod round_trip {
     use super::*;
 
-    fn round_trip<T: Encodable + Decodable + std::fmt::Debug + PartialEq>(items: Vec<T>) {
+    fn round_trip<T: Encode + Decode + std::fmt::Debug + PartialEq>(items: Vec<T>) {
         for item in items {
             let encoded = &item.as_ssz_bytes();
             assert_eq!(T::from_ssz_bytes(&encoded), Ok(item));

eth2/utils/ssz_derive/src/lib.rs

@@ -64,7 +64,7 @@ fn should_skip_serializing(field: &syn::Field) -> bool {
     false
 }
 
-/// Implements `ssz::Encodable` for some `struct`.
+/// Implements `ssz::Encode` for some `struct`.
 ///
 /// Fields are encoded in the order they are defined.
 #[proc_macro_derive(Encode, attributes(ssz))]
@@ -85,18 +85,18 @@ pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
     let field_types_c = field_types_a.clone();
 
     let output = quote! {
-        impl #impl_generics ssz::Encodable for #name #ty_generics #where_clause {
+        impl #impl_generics ssz::Encode for #name #ty_generics #where_clause {
             fn is_ssz_fixed_len() -> bool {
                 #(
-                    <#field_types_a as ssz::Encodable>::is_ssz_fixed_len() &&
+                    <#field_types_a as ssz::Encode>::is_ssz_fixed_len() &&
                 )*
                     true
             }
 
             fn ssz_fixed_len() -> usize {
-                if <Self as ssz::Encodable>::is_ssz_fixed_len() {
+                if <Self as ssz::Encode>::is_ssz_fixed_len() {
                     #(
-                        <#field_types_b as ssz::Encodable>::ssz_fixed_len() +
+                        <#field_types_b as ssz::Encode>::ssz_fixed_len() +
                     )*
                         0
                 } else {
@@ -106,7 +106,7 @@ pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
 
             fn ssz_append(&self, buf: &mut Vec<u8>) {
                 let offset = #(
-                        <#field_types_c as ssz::Encodable>::ssz_fixed_len() +
+                        <#field_types_c as ssz::Encode>::ssz_fixed_len() +
                     )*
                         0;
 
@@ -135,7 +135,7 @@ fn should_skip_deserializing(field: &syn::Field) -> bool {
     false
 }
 
-/// Implements `ssz::Decodable` for some `struct`.
+/// Implements `ssz::Decode` for some `struct`.
 ///
 /// Fields are decoded in the order they are defined.
 #[proc_macro_derive(Decode)]
@@ -177,11 +177,11 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
                     });
 
                     is_fixed_lens.push(quote! {
-                        <#ty as ssz::Decodable>::is_ssz_fixed_len()
+                        <#ty as ssz::Decode>::is_ssz_fixed_len()
                     });
 
                     fixed_lens.push(quote! {
-                        <#ty as ssz::Decodable>::ssz_fixed_len()
+                        <#ty as ssz::Decode>::ssz_fixed_len()
                     });
                 }
             }
@@ -190,7 +190,7 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
     }
 
     let output = quote! {
-        impl #impl_generics ssz::Decodable for #name #ty_generics #where_clause {
+        impl #impl_generics ssz::Decode for #name #ty_generics #where_clause {
             fn is_ssz_fixed_len() -> bool {
                 #(
                     #is_fixed_lens &&
@@ -199,7 +199,7 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
             }
 
             fn ssz_fixed_len() -> usize {
-                if <Self as ssz::Decodable>::is_ssz_fixed_len() {
+                if <Self as ssz::Decode>::is_ssz_fixed_len() {
                     #(
                         #fixed_lens +
                     )*

eth2/utils/ssz_derive/tests/tests.rs

@@ -1,4 +1,4 @@
-use ssz::Encodable;
+use ssz::Encode;
 use ssz_derive::Encode;
 
 #[derive(Debug, PartialEq, Encode)]

validator_client/src/attestation_producer/grpc.rs

@@ -1,7 +1,7 @@
 use super::beacon_node_attestation::BeaconNodeAttestation;
 use crate::block_producer::{BeaconNodeError, PublishOutcome};
 use protos::services_grpc::AttestationServiceClient;
-use ssz::{Decodable, Encodable};
+use ssz::{Decode, Encode};
 
 use protos::services::{
     Attestation as GrpcAttestation, ProduceAttestationDataRequest, PublishAttestationRequest,

validator_client/src/block_producer/grpc.rs

@@ -3,7 +3,7 @@ use protos::services::{
     BeaconBlock as GrpcBeaconBlock, ProduceBeaconBlockRequest, PublishBeaconBlockRequest,
 };
 use protos::services_grpc::BeaconBlockServiceClient;
-use ssz::{Decodable, Encodable};
+use ssz::{Decode, Encode};
 use std::sync::Arc;
 use types::{BeaconBlock, Signature, Slot};