Merge pull request #242 from sigp/ssz-derive

Derive macros for SSZ encode/decode

Cargo.toml

@@ -12,6 +12,7 @@ members = [
 	"eth2/utils/int_to_bytes",
 	"eth2/utils/slot_clock",
 	"eth2/utils/ssz",
+	"eth2/utils/ssz_derive",
 	"eth2/utils/swap_or_not_shuffle",
 	"eth2/utils/fisher_yates_shuffle",
 	"beacon_node",

eth2/types/Cargo.toml

@@ -18,6 +18,7 @@ serde_derive = "1.0"
 serde_json = "1.0"
 slog = "^2.2.3"
 ssz = { path = "../utils/ssz" }
+ssz_derive = { path = "../utils/ssz_derive" }
 swap_or_not_shuffle = { path = "../utils/swap_or_not_shuffle" }
 
 [dev-dependencies]

eth2/types/src/attestation.rs

@@ -2,9 +2,10 @@ use super::{AggregatePublicKey, AggregateSignature, AttestationData, Bitfield, H
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, Clone, PartialEq, Serialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode)]
 pub struct Attestation {
     pub aggregation_bitfield: Bitfield,
     pub data: AttestationData,
@@ -33,32 +34,6 @@ impl Attestation {
     }
 }
 
-impl Encodable for Attestation {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.aggregation_bitfield);
-        s.append(&self.data);
-        s.append(&self.custody_bitfield);
-        s.append(&self.aggregate_signature);
-    }
-}
-
-impl Decodable for Attestation {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (aggregation_bitfield, i) = Bitfield::ssz_decode(bytes, i)?;
-        let (data, i) = AttestationData::ssz_decode(bytes, i)?;
-        let (custody_bitfield, i) = Bitfield::ssz_decode(bytes, i)?;
-        let (aggregate_signature, i) = AggregateSignature::ssz_decode(bytes, i)?;
-
-        let attestation_record = Self {
-            aggregation_bitfield,
-            data,
-            custody_bitfield,
-            aggregate_signature,
-        };
-        Ok((attestation_record, i))
-    }
-}
-
 impl TreeHash for Attestation {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -85,7 +60,7 @@ impl<T: RngCore> TestRandom<T> for Attestation {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/attestation_data.rs

@@ -2,7 +2,8 @@ use crate::test_utils::TestRandom;
 use crate::{AttestationDataAndCustodyBit, Crosslink, Epoch, Hash256, Slot};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
 pub const SSZ_ATTESTION_DATA_LENGTH: usize = {
     8 +             // slot
@@ -15,7 +16,7 @@ pub const SSZ_ATTESTION_DATA_LENGTH: usize = {
     32 // justified_block_root
 };
 
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Hash)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Hash, Encode, Decode)]
 pub struct AttestationData {
     pub slot: Slot,
     pub shard: u64,
@@ -43,44 +44,6 @@ impl AttestationData {
     }
 }
 
-impl Encodable for AttestationData {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.slot);
-        s.append(&self.shard);
-        s.append(&self.beacon_block_root);
-        s.append(&self.epoch_boundary_root);
-        s.append(&self.shard_block_root);
-        s.append(&self.latest_crosslink);
-        s.append(&self.justified_epoch);
-        s.append(&self.justified_block_root);
-    }
-}
-
-impl Decodable for AttestationData {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (slot, i) = <_>::ssz_decode(bytes, i)?;
-        let (shard, i) = <_>::ssz_decode(bytes, i)?;
-        let (beacon_block_root, i) = <_>::ssz_decode(bytes, i)?;
-        let (epoch_boundary_root, i) = <_>::ssz_decode(bytes, i)?;
-        let (shard_block_root, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_crosslink, i) = <_>::ssz_decode(bytes, i)?;
-        let (justified_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (justified_block_root, i) = <_>::ssz_decode(bytes, i)?;
-
-        let attestation_data = AttestationData {
-            slot,
-            shard,
-            beacon_block_root,
-            epoch_boundary_root,
-            shard_block_root,
-            latest_crosslink,
-            justified_epoch,
-            justified_block_root,
-        };
-        Ok((attestation_data, i))
-    }
-}
-
 impl TreeHash for AttestationData {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -115,7 +78,7 @@ impl<T: RngCore> TestRandom<T> for AttestationData {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/attestation_data_and_custody_bit.rs

@@ -2,32 +2,15 @@ use super::AttestationData;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::TreeHash;
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, Clone, PartialEq, Default, Serialize)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Encode, Decode)]
 pub struct AttestationDataAndCustodyBit {
     pub data: AttestationData,
     pub custody_bit: bool,
 }
 
-impl Encodable for AttestationDataAndCustodyBit {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.data);
-        // TODO: deal with bools
-    }
-}
-
-impl Decodable for AttestationDataAndCustodyBit {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (data, i) = <_>::ssz_decode(bytes, i)?;
-        let custody_bit = false;
-
-        let attestation_data_and_custody_bit = AttestationDataAndCustodyBit { data, custody_bit };
-
-        Ok((attestation_data_and_custody_bit, i))
-    }
-}
-
 impl TreeHash for AttestationDataAndCustodyBit {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -52,7 +35,7 @@ impl<T: RngCore> TestRandom<T> for AttestationDataAndCustodyBit {
 mod test {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/attester_slashing.rs

@@ -1,36 +1,15 @@
 use crate::{test_utils::TestRandom, SlashableAttestation};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct AttesterSlashing {
     pub slashable_attestation_1: SlashableAttestation,
     pub slashable_attestation_2: SlashableAttestation,
 }
 
-impl Encodable for AttesterSlashing {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.slashable_attestation_1);
-        s.append(&self.slashable_attestation_2);
-    }
-}
-
-impl Decodable for AttesterSlashing {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (slashable_attestation_1, i) = <_>::ssz_decode(bytes, i)?;
-        let (slashable_attestation_2, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            AttesterSlashing {
-                slashable_attestation_1,
-                slashable_attestation_2,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for AttesterSlashing {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -53,7 +32,7 @@ impl<T: RngCore> TestRandom<T> for AttesterSlashing {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/beacon_block.rs

@@ -3,9 +3,10 @@ use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, ProposalSignedData, S
 use bls::Signature;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct BeaconBlock {
     pub slot: Slot,
     pub parent_root: Hash256,
@@ -59,43 +60,6 @@ impl BeaconBlock {
     }
 }
 
-impl Encodable for BeaconBlock {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.slot);
-        s.append(&self.parent_root);
-        s.append(&self.state_root);
-        s.append(&self.randao_reveal);
-        s.append(&self.eth1_data);
-        s.append(&self.signature);
-        s.append(&self.body);
-    }
-}
-
-impl Decodable for BeaconBlock {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (slot, i) = <_>::ssz_decode(bytes, i)?;
-        let (parent_root, i) = <_>::ssz_decode(bytes, i)?;
-        let (state_root, i) = <_>::ssz_decode(bytes, i)?;
-        let (randao_reveal, i) = <_>::ssz_decode(bytes, i)?;
-        let (eth1_data, i) = <_>::ssz_decode(bytes, i)?;
-        let (signature, i) = <_>::ssz_decode(bytes, i)?;
-        let (body, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                slot,
-                parent_root,
-                state_root,
-                randao_reveal,
-                eth1_data,
-                signature,
-                body,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for BeaconBlock {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -128,7 +92,7 @@ impl<T: RngCore> TestRandom<T> for BeaconBlock {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/beacon_block_body.rs

@@ -2,9 +2,10 @@ use super::{Attestation, AttesterSlashing, Deposit, Exit, ProposerSlashing};
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode)]
 pub struct BeaconBlockBody {
     pub proposer_slashings: Vec<ProposerSlashing>,
     pub attester_slashings: Vec<AttesterSlashing>,
@@ -13,37 +14,6 @@ pub struct BeaconBlockBody {
     pub exits: Vec<Exit>,
 }
 
-impl Encodable for BeaconBlockBody {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.proposer_slashings);
-        s.append_vec(&self.attester_slashings);
-        s.append_vec(&self.attestations);
-        s.append_vec(&self.deposits);
-        s.append_vec(&self.exits);
-    }
-}
-
-impl Decodable for BeaconBlockBody {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (proposer_slashings, i) = <_>::ssz_decode(bytes, i)?;
-        let (attester_slashings, i) = <_>::ssz_decode(bytes, i)?;
-        let (attestations, i) = <_>::ssz_decode(bytes, i)?;
-        let (deposits, i) = <_>::ssz_decode(bytes, i)?;
-        let (exits, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                proposer_slashings,
-                attester_slashings,
-                attestations,
-                deposits,
-                exits,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for BeaconBlockBody {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -72,7 +42,7 @@ impl<T: RngCore> TestRandom<T> for BeaconBlockBody {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/beacon_state.rs

@@ -9,7 +9,8 @@ use honey_badger_split::SplitExt;
 use log::trace;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 use swap_or_not_shuffle::get_permutated_index;
 
 mod tests;
@@ -51,7 +52,7 @@ macro_rules! safe_sub_assign {
     };
 }
 
-#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode)]
 pub struct BeaconState {
     // Misc
     pub slot: Slot,
@@ -967,97 +968,6 @@ impl From<AttestationParticipantsError> for InclusionError {
     }
 }
 
-impl Encodable for BeaconState {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.slot);
-        s.append(&self.genesis_time);
-        s.append(&self.fork);
-        s.append(&self.validator_registry);
-        s.append(&self.validator_balances);
-        s.append(&self.validator_registry_update_epoch);
-        s.append(&self.latest_randao_mixes);
-        s.append(&self.previous_epoch_start_shard);
-        s.append(&self.current_epoch_start_shard);
-        s.append(&self.previous_calculation_epoch);
-        s.append(&self.current_calculation_epoch);
-        s.append(&self.previous_epoch_seed);
-        s.append(&self.current_epoch_seed);
-        s.append(&self.previous_justified_epoch);
-        s.append(&self.justified_epoch);
-        s.append(&self.justification_bitfield);
-        s.append(&self.finalized_epoch);
-        s.append(&self.latest_crosslinks);
-        s.append(&self.latest_block_roots);
-        s.append(&self.latest_index_roots);
-        s.append(&self.latest_penalized_balances);
-        s.append(&self.latest_attestations);
-        s.append(&self.batched_block_roots);
-        s.append(&self.latest_eth1_data);
-        s.append(&self.eth1_data_votes);
-    }
-}
-
-impl Decodable for BeaconState {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (slot, i) = <_>::ssz_decode(bytes, i)?;
-        let (genesis_time, i) = <_>::ssz_decode(bytes, i)?;
-        let (fork, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_registry, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_balances, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_registry_update_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_randao_mixes, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_epoch_start_shard, i) = <_>::ssz_decode(bytes, i)?;
-        let (current_epoch_start_shard, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_calculation_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (current_calculation_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_epoch_seed, i) = <_>::ssz_decode(bytes, i)?;
-        let (current_epoch_seed, i) = <_>::ssz_decode(bytes, i)?;
-        let (previous_justified_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (justified_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (justification_bitfield, i) = <_>::ssz_decode(bytes, i)?;
-        let (finalized_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_crosslinks, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_block_roots, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_index_roots, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_penalized_balances, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_attestations, i) = <_>::ssz_decode(bytes, i)?;
-        let (batched_block_roots, i) = <_>::ssz_decode(bytes, i)?;
-        let (latest_eth1_data, i) = <_>::ssz_decode(bytes, i)?;
-        let (eth1_data_votes, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                slot,
-                genesis_time,
-                fork,
-                validator_registry,
-                validator_balances,
-                validator_registry_update_epoch,
-                latest_randao_mixes,
-                previous_epoch_start_shard,
-                current_epoch_start_shard,
-                previous_calculation_epoch,
-                current_calculation_epoch,
-                previous_epoch_seed,
-                current_epoch_seed,
-                previous_justified_epoch,
-                justified_epoch,
-                justification_bitfield,
-                finalized_epoch,
-                latest_crosslinks,
-                latest_block_roots,
-                latest_index_roots,
-                latest_penalized_balances,
-                latest_attestations,
-                batched_block_roots,
-                latest_eth1_data,
-                eth1_data_votes,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for BeaconState {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];

eth2/types/src/beacon_state/tests.rs

@@ -7,7 +7,7 @@ use crate::{
     Eth1Data, Hash256, Keypair,
 };
 use bls::create_proof_of_possession;
-use ssz::ssz_encode;
+use ssz::{ssz_encode, Decodable};
 
 struct BeaconStateTestBuilder {
     pub genesis_time: u64,

eth2/types/src/casper_slashing.rs

@@ -2,36 +2,15 @@ use super::SlashableVoteData;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct CasperSlashing {
     pub slashable_vote_data_1: SlashableVoteData,
     pub slashable_vote_data_2: SlashableVoteData,
 }
 
-impl Encodable for CasperSlashing {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.slashable_vote_data_1);
-        s.append(&self.slashable_vote_data_2);
-    }
-}
-
-impl Decodable for CasperSlashing {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (slashable_vote_data_1, i) = <_>::ssz_decode(bytes, i)?;
-        let (slashable_vote_data_2, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            CasperSlashing {
-                slashable_vote_data_1,
-                slashable_vote_data_2,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for CasperSlashing {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -54,7 +33,7 @@ impl<T: RngCore> TestRandom<T> for CasperSlashing {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/crosslink.rs

@@ -2,9 +2,10 @@ use crate::test_utils::TestRandom;
 use crate::{Epoch, Hash256};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Hash)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Hash, Encode, Decode)]
 pub struct Crosslink {
     pub epoch: Epoch,
     pub shard_block_root: Hash256,
@@ -20,28 +21,6 @@ impl Crosslink {
     }
 }
 
-impl Encodable for Crosslink {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.epoch);
-        s.append(&self.shard_block_root);
-    }
-}
-
-impl Decodable for Crosslink {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (shard_block_root, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                epoch,
-                shard_block_root,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for Crosslink {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -64,7 +43,7 @@ impl<T: RngCore> TestRandom<T> for Crosslink {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/deposit.rs

@@ -2,40 +2,16 @@ use super::{DepositData, Hash256};
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct Deposit {
     pub branch: Vec<Hash256>,
     pub index: u64,
     pub deposit_data: DepositData,
 }
 
-impl Encodable for Deposit {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.branch);
-        s.append(&self.index);
-        s.append(&self.deposit_data);
-    }
-}
-
-impl Decodable for Deposit {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (branch, i) = <_>::ssz_decode(bytes, i)?;
-        let (index, i) = <_>::ssz_decode(bytes, i)?;
-        let (deposit_data, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                branch,
-                index,
-                deposit_data,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for Deposit {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -60,7 +36,7 @@ impl<T: RngCore> TestRandom<T> for Deposit {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/deposit_data.rs

@@ -2,40 +2,16 @@ use super::DepositInput;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct DepositData {
     pub amount: u64,
     pub timestamp: u64,
     pub deposit_input: DepositInput,
 }
 
-impl Encodable for DepositData {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.amount);
-        s.append(&self.timestamp);
-        s.append(&self.deposit_input);
-    }
-}
-
-impl Decodable for DepositData {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (amount, i) = <_>::ssz_decode(bytes, i)?;
-        let (timestamp, i) = <_>::ssz_decode(bytes, i)?;
-        let (deposit_input, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                amount,
-                timestamp,
-                deposit_input,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for DepositData {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -60,7 +36,7 @@ impl<T: RngCore> TestRandom<T> for DepositData {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/deposit_input.rs

@@ -3,40 +3,16 @@ use crate::test_utils::TestRandom;
 use bls::{PublicKey, Signature};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct DepositInput {
     pub pubkey: PublicKey,
     pub withdrawal_credentials: Hash256,
     pub proof_of_possession: Signature,
 }
 
-impl Encodable for DepositInput {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.pubkey);
-        s.append(&self.withdrawal_credentials);
-        s.append(&self.proof_of_possession);
-    }
-}
-
-impl Decodable for DepositInput {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (pubkey, i) = <_>::ssz_decode(bytes, i)?;
-        let (withdrawal_credentials, i) = <_>::ssz_decode(bytes, i)?;
-        let (proof_of_possession, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                pubkey,
-                withdrawal_credentials,
-                proof_of_possession,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for DepositInput {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -61,7 +37,7 @@ impl<T: RngCore> TestRandom<T> for DepositInput {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/eth1_data.rs

@@ -2,37 +2,16 @@ use super::Hash256;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
 // Note: this is refer to as DepositRootVote in specs
-#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode)]
 pub struct Eth1Data {
     pub deposit_root: Hash256,
     pub block_hash: Hash256,
 }
 
-impl Encodable for Eth1Data {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.deposit_root);
-        s.append(&self.block_hash);
-    }
-}
-
-impl Decodable for Eth1Data {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (deposit_root, i) = <_>::ssz_decode(bytes, i)?;
-        let (block_hash, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                deposit_root,
-                block_hash,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for Eth1Data {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -55,7 +34,7 @@ impl<T: RngCore> TestRandom<T> for Eth1Data {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/eth1_data_vote.rs

@@ -2,37 +2,16 @@ use super::Eth1Data;
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
 // Note: this is refer to as DepositRootVote in specs
-#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode)]
 pub struct Eth1DataVote {
     pub eth1_data: Eth1Data,
     pub vote_count: u64,
 }
 
-impl Encodable for Eth1DataVote {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.eth1_data);
-        s.append(&self.vote_count);
-    }
-}
-
-impl Decodable for Eth1DataVote {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (eth1_data, i) = <_>::ssz_decode(bytes, i)?;
-        let (vote_count, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                eth1_data,
-                vote_count,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for Eth1DataVote {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -55,7 +34,7 @@ impl<T: RngCore> TestRandom<T> for Eth1DataVote {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/exit.rs

@@ -2,40 +2,16 @@ use crate::{test_utils::TestRandom, Epoch};
 use bls::Signature;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct Exit {
     pub epoch: Epoch,
     pub validator_index: u64,
     pub signature: Signature,
 }
 
-impl Encodable for Exit {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.epoch);
-        s.append(&self.validator_index);
-        s.append(&self.signature);
-    }
-}
-
-impl Decodable for Exit {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_index, i) = <_>::ssz_decode(bytes, i)?;
-        let (signature, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                epoch,
-                validator_index,
-                signature,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for Exit {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -60,7 +36,7 @@ impl<T: RngCore> TestRandom<T> for Exit {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/fork.rs

@@ -1,40 +1,16 @@
 use crate::{test_utils::TestRandom, Epoch};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, Clone, PartialEq, Default, Serialize)]
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Encode, Decode)]
 pub struct Fork {
     pub previous_version: u64,
     pub current_version: u64,
     pub epoch: Epoch,
 }
 
-impl Encodable for Fork {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.previous_version);
-        s.append(&self.current_version);
-        s.append(&self.epoch);
-    }
-}
-
-impl Decodable for Fork {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (previous_version, i) = <_>::ssz_decode(bytes, i)?;
-        let (current_version, i) = <_>::ssz_decode(bytes, i)?;
-        let (epoch, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                previous_version,
-                current_version,
-                epoch,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for Fork {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -59,7 +35,7 @@ impl<T: RngCore> TestRandom<T> for Fork {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/pending_attestation.rs

@@ -2,9 +2,10 @@ use crate::test_utils::TestRandom;
 use crate::{AttestationData, Bitfield, Slot};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, Clone, PartialEq, Serialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode)]
 pub struct PendingAttestation {
     pub aggregation_bitfield: Bitfield,
     pub data: AttestationData,
@@ -12,34 +13,6 @@ pub struct PendingAttestation {
     pub inclusion_slot: Slot,
 }
 
-impl Encodable for PendingAttestation {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.aggregation_bitfield);
-        s.append(&self.data);
-        s.append(&self.custody_bitfield);
-        s.append(&self.inclusion_slot);
-    }
-}
-
-impl Decodable for PendingAttestation {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (aggregation_bitfield, i) = <_>::ssz_decode(bytes, i)?;
-        let (data, i) = <_>::ssz_decode(bytes, i)?;
-        let (custody_bitfield, i) = <_>::ssz_decode(bytes, i)?;
-        let (inclusion_slot, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                data,
-                aggregation_bitfield,
-                custody_bitfield,
-                inclusion_slot,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for PendingAttestation {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -66,7 +39,7 @@ impl<T: RngCore> TestRandom<T> for PendingAttestation {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/proposal_signed_data.rs

@@ -2,40 +2,16 @@ use crate::test_utils::TestRandom;
 use crate::{Hash256, Slot};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Default, Serialize)]
+#[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode)]
 pub struct ProposalSignedData {
     pub slot: Slot,
     pub shard: u64,
     pub block_root: Hash256,
 }
 
-impl Encodable for ProposalSignedData {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.slot);
-        s.append(&self.shard);
-        s.append(&self.block_root);
-    }
-}
-
-impl Decodable for ProposalSignedData {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (slot, i) = <_>::ssz_decode(bytes, i)?;
-        let (shard, i) = <_>::ssz_decode(bytes, i)?;
-        let (block_root, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            ProposalSignedData {
-                slot,
-                shard,
-                block_root,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for ProposalSignedData {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -60,7 +36,7 @@ impl<T: RngCore> TestRandom<T> for ProposalSignedData {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/proposer_slashing.rs

@@ -3,9 +3,10 @@ use crate::test_utils::TestRandom;
 use bls::Signature;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct ProposerSlashing {
     pub proposer_index: u64,
     pub proposal_data_1: ProposalSignedData,
@@ -14,37 +15,6 @@ pub struct ProposerSlashing {
     pub proposal_signature_2: Signature,
 }
 
-impl Encodable for ProposerSlashing {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.proposer_index);
-        s.append(&self.proposal_data_1);
-        s.append(&self.proposal_signature_1);
-        s.append(&self.proposal_data_2);
-        s.append(&self.proposal_signature_2);
-    }
-}
-
-impl Decodable for ProposerSlashing {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (proposer_index, i) = <_>::ssz_decode(bytes, i)?;
-        let (proposal_data_1, i) = <_>::ssz_decode(bytes, i)?;
-        let (proposal_signature_1, i) = <_>::ssz_decode(bytes, i)?;
-        let (proposal_data_2, i) = <_>::ssz_decode(bytes, i)?;
-        let (proposal_signature_2, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            ProposerSlashing {
-                proposer_index,
-                proposal_data_1,
-                proposal_signature_1,
-                proposal_data_2,
-                proposal_signature_2,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for ProposerSlashing {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -73,7 +43,7 @@ impl<T: RngCore> TestRandom<T> for ProposerSlashing {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/shard_reassignment_record.rs

@@ -1,40 +1,16 @@
 use crate::{test_utils::TestRandom, Slot};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct ShardReassignmentRecord {
     pub validator_index: u64,
     pub shard: u64,
     pub slot: Slot,
 }
 
-impl Encodable for ShardReassignmentRecord {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.validator_index);
-        s.append(&self.shard);
-        s.append(&self.slot);
-    }
-}
-
-impl Decodable for ShardReassignmentRecord {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (validator_index, i) = <_>::ssz_decode(bytes, i)?;
-        let (shard, i) = <_>::ssz_decode(bytes, i)?;
-        let (slot, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                validator_index,
-                shard,
-                slot,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for ShardReassignmentRecord {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -59,7 +35,7 @@ impl<T: RngCore> TestRandom<T> for ShardReassignmentRecord {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/slashable_attestation.rs

@@ -1,9 +1,10 @@
 use crate::{test_utils::TestRandom, AggregateSignature, AttestationData, Bitfield};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct SlashableAttestation {
     pub validator_indices: Vec<u64>,
     pub data: AttestationData,
@@ -11,34 +12,6 @@ pub struct SlashableAttestation {
     pub aggregate_signature: AggregateSignature,
 }
 
-impl Encodable for SlashableAttestation {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.validator_indices);
-        s.append(&self.data);
-        s.append(&self.custody_bitfield);
-        s.append(&self.aggregate_signature);
-    }
-}
-
-impl Decodable for SlashableAttestation {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (validator_indices, i) = <_>::ssz_decode(bytes, i)?;
-        let (data, i) = <_>::ssz_decode(bytes, i)?;
-        let (custody_bitfield, i) = <_>::ssz_decode(bytes, i)?;
-        let (aggregate_signature, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            SlashableAttestation {
-                validator_indices,
-                data,
-                custody_bitfield,
-                aggregate_signature,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for SlashableAttestation {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -65,7 +38,7 @@ impl<T: RngCore> TestRandom<T> for SlashableAttestation {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/slashable_vote_data.rs

@@ -4,9 +4,10 @@ use crate::test_utils::TestRandom;
 use bls::AggregateSignature;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
-#[derive(Debug, PartialEq, Clone, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode)]
 pub struct SlashableVoteData {
     pub custody_bit_0_indices: Vec<u32>,
     pub custody_bit_1_indices: Vec<u32>,
@@ -35,34 +36,6 @@ impl SlashableVoteData {
     }
 }
 
-impl Encodable for SlashableVoteData {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append_vec(&self.custody_bit_0_indices);
-        s.append_vec(&self.custody_bit_1_indices);
-        s.append(&self.data);
-        s.append(&self.aggregate_signature);
-    }
-}
-
-impl Decodable for SlashableVoteData {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (custody_bit_0_indices, i) = <_>::ssz_decode(bytes, i)?;
-        let (custody_bit_1_indices, i) = <_>::ssz_decode(bytes, i)?;
-        let (data, i) = <_>::ssz_decode(bytes, i)?;
-        let (aggregate_signature, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            SlashableVoteData {
-                custody_bit_0_indices,
-                custody_bit_1_indices,
-                data,
-                aggregate_signature,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for SlashableVoteData {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -91,7 +64,7 @@ mod tests {
     use crate::chain_spec::ChainSpec;
     use crate::slot_epoch::{Epoch, Slot};
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_is_double_vote_true() {

eth2/types/src/validator_registry_delta_block.rs

@@ -2,10 +2,11 @@ use crate::{test_utils::TestRandom, Hash256, Slot};
 use bls::PublicKey;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz::{hash, TreeHash};
+use ssz_derive::{Decode, Encode};
 
 // The information gathered from the PoW chain validator registration function.
-#[derive(Debug, Clone, PartialEq, Serialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode)]
 pub struct ValidatorRegistryDeltaBlock {
     pub latest_registry_delta_root: Hash256,
     pub validator_index: u32,
@@ -27,37 +28,6 @@ impl Default for ValidatorRegistryDeltaBlock {
     }
 }
 
-impl Encodable for ValidatorRegistryDeltaBlock {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.latest_registry_delta_root);
-        s.append(&self.validator_index);
-        s.append(&self.pubkey);
-        s.append(&self.slot);
-        s.append(&self.flag);
-    }
-}
-
-impl Decodable for ValidatorRegistryDeltaBlock {
-    fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
-        let (latest_registry_delta_root, i) = <_>::ssz_decode(bytes, i)?;
-        let (validator_index, i) = <_>::ssz_decode(bytes, i)?;
-        let (pubkey, i) = <_>::ssz_decode(bytes, i)?;
-        let (slot, i) = <_>::ssz_decode(bytes, i)?;
-        let (flag, i) = <_>::ssz_decode(bytes, i)?;
-
-        Ok((
-            Self {
-                latest_registry_delta_root,
-                validator_index,
-                pubkey,
-                slot,
-                flag,
-            },
-            i,
-        ))
-    }
-}
-
 impl TreeHash for ValidatorRegistryDeltaBlock {
     fn hash_tree_root_internal(&self) -> Vec<u8> {
         let mut result: Vec<u8> = vec![];
@@ -86,7 +56,7 @@ impl<T: RngCore> TestRandom<T> for ValidatorRegistryDeltaBlock {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/utils/ssz/src/impl_decode.rs

@@ -39,6 +39,21 @@ impl Decodable for u8 {
     }
 }
 
+impl Decodable for bool {
+    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), DecodeError> {
+        if index >= bytes.len() {
+            Err(DecodeError::TooShort)
+        } else {
+            let result = match bytes[index] {
+                0b0000_0000 => false,
+                0b1000_0000 => true,
+                _ => return Err(DecodeError::Invalid),
+            };
+            Ok((result, 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 {
@@ -215,4 +230,20 @@ mod tests {
         let result: u16 = decode_ssz(&vec![0, 0, 0, 0, 1], 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();
+        assert_eq!(index, 1);
+        assert_eq!(result, false);
+
+        let (result, index): (bool, usize) = decode_ssz(&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);
+        assert_eq!(result, Err(DecodeError::Invalid));
+    }
 }

eth2/utils/ssz/src/impl_encode.rs

@@ -46,6 +46,13 @@ impl_encodable_for_uint!(u32, 32);
 impl_encodable_for_uint!(u64, 64);
 impl_encodable_for_uint!(usize, 64);
 
+impl Encodable for bool {
+    fn ssz_append(&self, s: &mut SszStream) {
+        let byte = if *self { 0b1000_0000 } else { 0b0000_0000 };
+        s.append_encoded_raw(&[byte]);
+    }
+}
+
 impl Encodable for H256 {
     fn ssz_append(&self, s: &mut SszStream) {
         s.append_encoded_raw(&self.to_vec());
@@ -206,4 +213,17 @@ mod tests {
         ssz.append(&x);
         assert_eq!(ssz.drain(), vec![255, 255, 255, 255, 255, 255, 255, 255]);
     }
+
+    #[test]
+    fn test_ssz_encode_bool() {
+        let x: bool = false;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0b0000_0000]);
+
+        let x: bool = true;
+        let mut ssz = SszStream::new();
+        ssz.append(&x);
+        assert_eq!(ssz.drain(), vec![0b1000_0000]);
+    }
 }

eth2/utils/ssz_derive/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "ssz_derive"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+edition = "2018"
+description = "Procedural derive macros for SSZ encoding and decoding."
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "0.15"
+quote = "0.6"
+ssz = { path = "../ssz" }

eth2/utils/ssz_derive/src/lib.rs

@@ -0,0 +1,128 @@
+//! Provides the following procedural derive macros:
+//!
+//! - `#[derive(Encode)]`
+//! - `#[derive(Decode)]`
+//!
+//! These macros provide SSZ encoding/decoding for a `struct`. Fields are encoded/decoded in the
+//! order they are defined.
+//!
+//! Presently, only `structs` with named fields are supported. `enum`s and tuple-structs are
+//! unsupported.
+//!
+//! Example:
+//! ```
+//! use ssz::{ssz_encode, Decodable};
+//! use ssz_derive::{Encode, Decode};
+//!
+//! #[derive(Encode, Decode)]
+//! struct Foo {
+//!     pub bar: bool,
+//!     pub baz: u64,
+//! }
+//!
+//! fn main() {
+//!     let foo = Foo {
+//!         bar: true,
+//!         baz: 42,
+//!     };
+//!
+//!     let bytes = ssz_encode(&foo);
+//!
+//!     let (decoded_foo, _i) = Foo::ssz_decode(&bytes, 0).unwrap();
+//!
+//!     assert_eq!(foo.baz, decoded_foo.baz);
+//! }
+//! ```
+
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
+
+/// Returns a Vec of `syn::Ident` for each named field in the struct.
+///
+/// # Panics
+/// Any unnamed struct field (like in a tuple struct) will raise a panic at compile time.
+fn get_named_field_idents<'a>(struct_data: &'a syn::DataStruct) -> Vec<&'a syn::Ident> {
+    struct_data
+        .fields
+        .iter()
+        .map(|f| match &f.ident {
+            Some(ref ident) => ident,
+            _ => panic!("ssz_derive only supports named struct fields."),
+        })
+        .collect()
+}
+
+/// Implements `ssz::Encodable` for some `struct`.
+///
+/// Fields are encoded in the order they are defined.
+#[proc_macro_derive(Encode)]
+pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
+    let item = parse_macro_input!(input as DeriveInput);
+
+    let name = &item.ident;
+
+    let struct_data = match &item.data {
+        syn::Data::Struct(s) => s,
+        _ => panic!("ssz_derive only supports structs."),
+    };
+
+    let field_idents = get_named_field_idents(&struct_data);
+
+    let output = quote! {
+        impl ssz::Encodable for #name {
+            fn ssz_append(&self, s: &mut ssz::SszStream) {
+                #(
+                    s.append(&self.#field_idents);
+                )*
+            }
+        }
+    };
+    output.into()
+}
+
+/// Implements `ssz::Decodable` for some `struct`.
+///
+/// Fields are decoded in the order they are defined.
+#[proc_macro_derive(Decode)]
+pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
+    let item = parse_macro_input!(input as DeriveInput);
+
+    let name = &item.ident;
+
+    let struct_data = match &item.data {
+        syn::Data::Struct(s) => s,
+        _ => panic!("ssz_derive only supports structs."),
+    };
+
+    let field_idents = get_named_field_idents(&struct_data);
+
+    // Using a var in an iteration always consumes the var, therefore we must make a `fields_a` and
+    // a `fields_b` in order to perform two loops.
+    //
+    // https://github.com/dtolnay/quote/issues/8
+    let field_idents_a = &field_idents;
+    let field_idents_b = &field_idents;
+
+    let output = quote! {
+        impl ssz::Decodable for #name {
+            fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), ssz::DecodeError> {
+                #(
+                    let (#field_idents_a, i) = <_>::ssz_decode(bytes, i)?;
+                )*
+
+                Ok((
+                    Self {
+                        #(
+                            #field_idents_b,
+                        )*
+                    },
+                    i
+                ))
+            }
+        }
+    };
+    output.into()
+}