diff --git a/Cargo.toml b/Cargo.toml index 302c04154..d92b1a303 100644 --- a/Cargo.toml +++ b/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", diff --git a/eth2/types/Cargo.toml b/eth2/types/Cargo.toml index 4c5be65b5..f51e20236 100644 --- a/eth2/types/Cargo.toml +++ b/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] diff --git a/eth2/types/src/attestation.rs b/eth2/types/src/attestation.rs index 50e0949e1..7388a8e49 100644 --- a/eth2/types/src/attestation.rs +++ b/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 { let mut result: Vec = vec![]; @@ -85,7 +60,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/attestation_data.rs b/eth2/types/src/attestation_data.rs index 6f98c557c..7edb0b72b 100644 --- a/eth2/types/src/attestation_data.rs +++ b/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 { let mut result: Vec = vec![]; @@ -115,7 +78,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/attestation_data_and_custody_bit.rs b/eth2/types/src/attestation_data_and_custody_bit.rs index 48add3d21..3f107be82 100644 --- a/eth2/types/src/attestation_data_and_custody_bit.rs +++ b/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 { let mut result: Vec = vec![]; @@ -52,7 +35,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/attester_slashing.rs b/eth2/types/src/attester_slashing.rs index 80fa673a7..f84998324 100644 --- a/eth2/types/src/attester_slashing.rs +++ b/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 { let mut result: Vec = vec![]; @@ -53,7 +32,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/beacon_block.rs b/eth2/types/src/beacon_block.rs index f0661a1c9..c252d03f7 100644 --- a/eth2/types/src/beacon_block.rs +++ b/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 { let mut result: Vec = vec![]; @@ -128,7 +92,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/beacon_block_body.rs b/eth2/types/src/beacon_block_body.rs index 9b25c919a..e051f5940 100644 --- a/eth2/types/src/beacon_block_body.rs +++ b/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, pub attester_slashings: Vec, @@ -13,37 +14,6 @@ pub struct BeaconBlockBody { pub exits: Vec, } -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 { let mut result: Vec = vec![]; @@ -72,7 +42,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/beacon_state.rs b/eth2/types/src/beacon_state.rs index 2216e9516..21deb6fe7 100644 --- a/eth2/types/src/beacon_state.rs +++ b/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 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 { let mut result: Vec = vec![]; diff --git a/eth2/types/src/beacon_state/tests.rs b/eth2/types/src/beacon_state/tests.rs index 2b7c5b539..7e25d4dba 100644 --- a/eth2/types/src/beacon_state/tests.rs +++ b/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, diff --git a/eth2/types/src/casper_slashing.rs b/eth2/types/src/casper_slashing.rs index f9dc2f178..6346db65c 100644 --- a/eth2/types/src/casper_slashing.rs +++ b/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 { let mut result: Vec = vec![]; @@ -54,7 +33,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/crosslink.rs b/eth2/types/src/crosslink.rs index 90ee5dc9b..19c71f604 100644 --- a/eth2/types/src/crosslink.rs +++ b/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 { let mut result: Vec = vec![]; @@ -64,7 +43,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/deposit.rs b/eth2/types/src/deposit.rs index eebcdb5d0..78f43532a 100644 --- a/eth2/types/src/deposit.rs +++ b/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, 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 { let mut result: Vec = vec![]; @@ -60,7 +36,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/deposit_data.rs b/eth2/types/src/deposit_data.rs index 443c371e3..8f49deb3c 100644 --- a/eth2/types/src/deposit_data.rs +++ b/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 { let mut result: Vec = vec![]; @@ -60,7 +36,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/deposit_input.rs b/eth2/types/src/deposit_input.rs index 440fcba1c..7556fc2ca 100644 --- a/eth2/types/src/deposit_input.rs +++ b/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 { let mut result: Vec = vec![]; @@ -61,7 +37,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/eth1_data.rs b/eth2/types/src/eth1_data.rs index d68e611dd..b0dc14e7a 100644 --- a/eth2/types/src/eth1_data.rs +++ b/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 { let mut result: Vec = vec![]; @@ -55,7 +34,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/eth1_data_vote.rs b/eth2/types/src/eth1_data_vote.rs index a09b0888d..eda6e6a6a 100644 --- a/eth2/types/src/eth1_data_vote.rs +++ b/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 { let mut result: Vec = vec![]; @@ -55,7 +34,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/exit.rs b/eth2/types/src/exit.rs index a1dcd6122..18d743b83 100644 --- a/eth2/types/src/exit.rs +++ b/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 { let mut result: Vec = vec![]; @@ -60,7 +36,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/fork.rs b/eth2/types/src/fork.rs index 829d7d4a9..85d530e19 100644 --- a/eth2/types/src/fork.rs +++ b/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 { let mut result: Vec = vec![]; @@ -59,7 +35,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/pending_attestation.rs b/eth2/types/src/pending_attestation.rs index b84a63297..42f990210 100644 --- a/eth2/types/src/pending_attestation.rs +++ b/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 { let mut result: Vec = vec![]; @@ -66,7 +39,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/proposal_signed_data.rs b/eth2/types/src/proposal_signed_data.rs index 3069a7431..63c0f1ce6 100644 --- a/eth2/types/src/proposal_signed_data.rs +++ b/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 { let mut result: Vec = vec![]; @@ -60,7 +36,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/proposer_slashing.rs b/eth2/types/src/proposer_slashing.rs index c76609335..b3a819a7f 100644 --- a/eth2/types/src/proposer_slashing.rs +++ b/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 { let mut result: Vec = vec![]; @@ -73,7 +43,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/shard_reassignment_record.rs b/eth2/types/src/shard_reassignment_record.rs index 374499a13..511fe13ca 100644 --- a/eth2/types/src/shard_reassignment_record.rs +++ b/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 { let mut result: Vec = vec![]; @@ -59,7 +35,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/slashable_attestation.rs b/eth2/types/src/slashable_attestation.rs index 862d93c60..676954ec2 100644 --- a/eth2/types/src/slashable_attestation.rs +++ b/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, 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 { let mut result: Vec = vec![]; @@ -65,7 +38,7 @@ impl TestRandom 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() { diff --git a/eth2/types/src/slashable_vote_data.rs b/eth2/types/src/slashable_vote_data.rs index 80aaf2a2f..bdd1d0619 100644 --- a/eth2/types/src/slashable_vote_data.rs +++ b/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, pub custody_bit_1_indices: Vec, @@ -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 { let mut result: Vec = 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() { diff --git a/eth2/types/src/validator_registry_delta_block.rs b/eth2/types/src/validator_registry_delta_block.rs index 13d2e0059..14f9c6ce5 100644 --- a/eth2/types/src/validator_registry_delta_block.rs +++ b/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 { let mut result: Vec = vec![]; @@ -86,7 +56,7 @@ impl TestRandom 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() { diff --git a/eth2/utils/ssz/src/impl_decode.rs b/eth2/utils/ssz/src/impl_decode.rs index 134e438e1..b9ca48f9b 100644 --- a/eth2/utils/ssz/src/impl_decode.rs +++ b/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)); + } } diff --git a/eth2/utils/ssz/src/impl_encode.rs b/eth2/utils/ssz/src/impl_encode.rs index 8714cf75f..5f73b8483 100644 --- a/eth2/utils/ssz/src/impl_encode.rs +++ b/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]); + } } diff --git a/eth2/utils/ssz_derive/Cargo.toml b/eth2/utils/ssz_derive/Cargo.toml new file mode 100644 index 000000000..3e58d752b --- /dev/null +++ b/eth2/utils/ssz_derive/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "ssz_derive" +version = "0.1.0" +authors = ["Paul Hauner "] +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" } diff --git a/eth2/utils/ssz_derive/src/lib.rs b/eth2/utils/ssz_derive/src/lib.rs new file mode 100644 index 000000000..1bc5caef1 --- /dev/null +++ b/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() +}