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/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs index d0e7b7f8f..1065f661d 100644 --- a/beacon_node/beacon_chain/src/beacon_chain.rs +++ b/beacon_node/beacon_chain/src/beacon_chain.rs @@ -359,6 +359,7 @@ where self.fork_choice.write().add_attestation( free_attestation.validator_index, &free_attestation.data.beacon_block_root, + &self.spec, )?; Ok(aggregation_outcome) } @@ -488,7 +489,9 @@ where self.state_store.put(&state_root, &ssz_encode(&state)[..])?; // run the fork_choice add_block logic - self.fork_choice.write().add_block(&block, &block_root)?; + self.fork_choice + .write() + .add_block(&block, &block_root, &self.spec)?; // If the parent block was the parent_block, automatically update the canonical head. // @@ -569,7 +572,10 @@ where pub fn fork_choice(&self) -> Result<(), Error> { let present_head = self.finalized_head().beacon_block_root; - let new_head = self.fork_choice.write().find_head(&present_head)?; + let new_head = self + .fork_choice + .write() + .find_head(&present_head, &self.spec)?; if new_head != present_head { let block = self diff --git a/beacon_node/beacon_chain/src/lib.rs b/beacon_node/beacon_chain/src/lib.rs index d7d1d9664..bd3ee0788 100644 --- a/beacon_node/beacon_chain/src/lib.rs +++ b/beacon_node/beacon_chain/src/lib.rs @@ -6,4 +6,4 @@ pub use self::beacon_chain::{ BeaconChain, BlockProcessingOutcome, Error, InvalidBlock, ValidBlock, }; pub use self::checkpoint::CheckPoint; -pub use fork_choice::{ForkChoice, ForkChoiceAlgorithms, ForkChoiceError}; +pub use fork_choice::{ForkChoice, ForkChoiceAlgorithm, ForkChoiceError}; diff --git a/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs b/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs index a15e82aa2..d3bd444d1 100644 --- a/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs +++ b/beacon_node/beacon_chain/test_harness/src/beacon_chain_harness.rs @@ -6,7 +6,7 @@ use db::{ stores::{BeaconBlockStore, BeaconStateStore}, MemoryDB, }; -use fork_choice::OptimisedLMDGhost; +use fork_choice::BitwiseLMDGhost; use log::debug; use rayon::prelude::*; use slot_clock::TestingSlotClock; @@ -28,7 +28,7 @@ use types::{ /// is not useful for testing that multiple beacon nodes can reach consensus. pub struct BeaconChainHarness { pub db: Arc, - pub beacon_chain: Arc>>, + pub beacon_chain: Arc>>, pub block_store: Arc>, pub state_store: Arc>, pub validators: Vec, @@ -46,7 +46,7 @@ impl BeaconChainHarness { let state_store = Arc::new(BeaconStateStore::new(db.clone())); let genesis_time = 1_549_935_547; // 12th Feb 2018 (arbitrary value in the past). let slot_clock = TestingSlotClock::new(spec.genesis_slot.as_u64()); - let fork_choice = OptimisedLMDGhost::new(block_store.clone(), state_store.clone()); + let fork_choice = BitwiseLMDGhost::new(block_store.clone(), state_store.clone()); let latest_eth1_data = Eth1Data { deposit_root: Hash256::zero(), block_hash: Hash256::zero(), diff --git a/beacon_node/beacon_chain/test_harness/src/validator_harness/mod.rs b/beacon_node/beacon_chain/test_harness/src/validator_harness/mod.rs index f48309541..60c2f8ecf 100644 --- a/beacon_node/beacon_chain/test_harness/src/validator_harness/mod.rs +++ b/beacon_node/beacon_chain/test_harness/src/validator_harness/mod.rs @@ -10,7 +10,7 @@ use block_proposer::{BlockProducer, Error as BlockPollError}; use db::MemoryDB; use direct_beacon_node::DirectBeaconNode; use direct_duties::DirectDuties; -use fork_choice::OptimisedLMDGhost; +use fork_choice::BitwiseLMDGhost; use local_signer::LocalSigner; use slot_clock::TestingSlotClock; use std::sync::Arc; @@ -36,20 +36,20 @@ pub enum AttestationProduceError { pub struct ValidatorHarness { pub block_producer: BlockProducer< TestingSlotClock, - DirectBeaconNode>, - DirectDuties>, + DirectBeaconNode>, + DirectDuties>, LocalSigner, >, pub attester: Attester< TestingSlotClock, - DirectBeaconNode>, - DirectDuties>, + DirectBeaconNode>, + DirectDuties>, LocalSigner, >, pub spec: Arc, - pub epoch_map: Arc>>, + pub epoch_map: Arc>>, pub keypair: Keypair, - pub beacon_node: Arc>>, + pub beacon_node: Arc>>, pub slot_clock: Arc, pub signer: Arc, } @@ -61,7 +61,7 @@ impl ValidatorHarness { /// A `BlockProducer` and `Attester` is created.. pub fn new( keypair: Keypair, - beacon_chain: Arc>>, + beacon_chain: Arc>>, spec: Arc, ) -> Self { let slot_clock = Arc::new(TestingSlotClock::new(spec.genesis_slot.as_u64())); diff --git a/beacon_node/src/main.rs b/beacon_node/src/main.rs index 2b6cdddcd..b9ef2c8a7 100644 --- a/beacon_node/src/main.rs +++ b/beacon_node/src/main.rs @@ -14,7 +14,7 @@ use db::{ stores::{BeaconBlockStore, BeaconStateStore}, MemoryDB, }; -use fork_choice::optimised_lmd_ghost::OptimisedLMDGhost; +use fork_choice::BitwiseLMDGhost; use slog::{error, info, o, Drain}; use slot_clock::SystemTimeSlotClock; use std::sync::Arc; @@ -81,7 +81,7 @@ fn main() { let slot_clock = SystemTimeSlotClock::new(genesis_time, spec.slot_duration) .expect("Unable to load SystemTimeSlotClock"); // Choose the fork choice - let fork_choice = OptimisedLMDGhost::new(block_store.clone(), state_store.clone()); + let fork_choice = BitwiseLMDGhost::new(block_store.clone(), state_store.clone()); /* * Generate some random data to start a chain with. diff --git a/eth2/fork_choice/Cargo.toml b/eth2/fork_choice/Cargo.toml index 72a653032..210f3c235 100644 --- a/eth2/fork_choice/Cargo.toml +++ b/eth2/fork_choice/Cargo.toml @@ -9,10 +9,13 @@ db = { path = "../../beacon_node/db" } ssz = { path = "../utils/ssz" } types = { path = "../types" } fast-math = "0.1.1" -byteorder = "1.3.1" +log = "0.4.6" +bit-vec = "0.5.0" [dev-dependencies] +hex = "0.3.2" yaml-rust = "0.4.2" bls = { path = "../utils/bls" } slot_clock = { path = "../utils/slot_clock" } beacon_chain = { path = "../../beacon_node/beacon_chain" } +env_logger = "0.6.0" diff --git a/eth2/fork_choice/src/optimised_lmd_ghost.rs b/eth2/fork_choice/src/bitwise_lmd_ghost.rs similarity index 72% rename from eth2/fork_choice/src/optimised_lmd_ghost.rs rename to eth2/fork_choice/src/bitwise_lmd_ghost.rs index 6b21e39f8..e1d246e92 100644 --- a/eth2/fork_choice/src/optimised_lmd_ghost.rs +++ b/eth2/fork_choice/src/bitwise_lmd_ghost.rs @@ -1,49 +1,25 @@ -// Copyright 2019 Sigma Prime Pty Ltd. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the "Software"), -// to deal in the Software without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - -extern crate byteorder; +extern crate bit_vec; extern crate fast_math; + use crate::{ForkChoice, ForkChoiceError}; -use byteorder::{BigEndian, ByteOrder}; +use bit_vec::BitVec; use db::{ stores::{BeaconBlockStore, BeaconStateStore}, ClientDB, }; use fast_math::log2_raw; +use log::{debug, trace}; use std::collections::HashMap; use std::sync::Arc; use types::{ readers::BeaconBlockReader, validator_registry::get_active_validator_indices, BeaconBlock, - Hash256, Slot, SlotHeight, + ChainSpec, Hash256, Slot, SlotHeight, }; //TODO: Pruning - Children //TODO: Handle Syncing -//TODO: Sort out global constants -const GENESIS_SLOT: u64 = 0; -const FORK_CHOICE_BALANCE_INCREMENT: u64 = 1e9 as u64; -const MAX_DEPOSIT_AMOUNT: u64 = 32e9 as u64; -const EPOCH_LENGTH: u64 = 64; - -/// The optimised LMD-GHOST fork choice rule. +/// The optimised bitwise LMD-GHOST fork choice rule. /// NOTE: This uses u32 to represent difference between block heights. Thus this is only /// applicable for block height differences in the range of a u32. /// This can potentially be parallelized in some parts. @@ -51,6 +27,13 @@ const EPOCH_LENGTH: u64 = 64; // the comparison. Log2_raw takes 2ns according to the documentation. #[inline] fn log2_int(x: u32) -> u32 { + if x == 0 { + return 0; + } + assert!( + x <= std::f32::MAX as u32, + "Height too large for fast log in bitwise fork choice" + ); log2_raw(x as f32) as u32 } @@ -58,8 +41,8 @@ fn power_of_2_below(x: u32) -> u32 { 2u32.pow(log2_int(x)) } -/// Stores the necessary data structures to run the optimised lmd ghost algorithm. -pub struct OptimisedLMDGhost { +/// Stores the necessary data structures to run the optimised bitwise lmd ghost algorithm. +pub struct BitwiseLMDGhost { /// A cache of known ancestors at given heights for a specific block. //TODO: Consider FnvHashMap cache: HashMap, Hash256>, @@ -78,7 +61,7 @@ pub struct OptimisedLMDGhost { max_known_height: SlotHeight, } -impl OptimisedLMDGhost +impl BitwiseLMDGhost where T: ClientDB + Sized, { @@ -86,7 +69,7 @@ where block_store: Arc>, state_store: Arc>, ) -> Self { - OptimisedLMDGhost { + BitwiseLMDGhost { cache: HashMap::new(), ancestors: vec![HashMap::new(); 16], latest_attestation_targets: HashMap::new(), @@ -103,6 +86,7 @@ where &self, state_root: &Hash256, block_slot: Slot, + spec: &ChainSpec, ) -> Result, ForkChoiceError> { // get latest votes // Note: Votes are weighted by min(balance, MAX_DEPOSIT_AMOUNT) // @@ -117,25 +101,31 @@ where let active_validator_indices = get_active_validator_indices( ¤t_state.validator_registry[..], - block_slot.epoch(EPOCH_LENGTH), + block_slot.epoch(spec.epoch_length), ); for index in active_validator_indices { - let balance = - std::cmp::min(current_state.validator_balances[index], MAX_DEPOSIT_AMOUNT) - / FORK_CHOICE_BALANCE_INCREMENT; + let balance = std::cmp::min( + current_state.validator_balances[index], + spec.max_deposit_amount, + ) / spec.fork_choice_balance_increment; if balance > 0 { if let Some(target) = self.latest_attestation_targets.get(&(index as u64)) { *latest_votes.entry(*target).or_insert_with(|| 0) += balance; } } } - + trace!("Latest votes: {:?}", latest_votes); Ok(latest_votes) } /// Gets the ancestor at a given height `at_height` of a block specified by `block_hash`. - fn get_ancestor(&mut self, block_hash: Hash256, at_height: SlotHeight) -> Option { + fn get_ancestor( + &mut self, + block_hash: Hash256, + target_height: SlotHeight, + spec: &ChainSpec, + ) -> Option { // return None if we can't get the block from the db. let block_height = { let block_slot = self @@ -145,32 +135,31 @@ where .expect("Should have returned already if None") .slot; - block_slot.height(Slot::from(GENESIS_SLOT)) + block_slot.height(spec.genesis_slot) }; // verify we haven't exceeded the block height - if at_height >= block_height { - if at_height > block_height { + if target_height >= block_height { + if target_height > block_height { return None; } else { return Some(block_hash); } } // check if the result is stored in our cache - let cache_key = CacheKey::new(&block_hash, at_height.as_u32()); + let cache_key = CacheKey::new(&block_hash, target_height.as_u32()); if let Some(ancestor) = self.cache.get(&cache_key) { return Some(*ancestor); } // not in the cache recursively search for ancestors using a log-lookup - if let Some(ancestor) = { let ancestor_lookup = self.ancestors - [log2_int((block_height - at_height - 1u64).as_u32()) as usize] + [log2_int((block_height - target_height - 1u64).as_u32()) as usize] .get(&block_hash) //TODO: Panic if we can't lookup and fork choice fails .expect("All blocks should be added to the ancestor log lookup table"); - self.get_ancestor(*ancestor_lookup, at_height) + self.get_ancestor(*ancestor_lookup, target_height, &spec) } { // add the result to the cache self.cache.insert(cache_key, ancestor); @@ -185,15 +174,17 @@ where &mut self, latest_votes: &HashMap, block_height: SlotHeight, + spec: &ChainSpec, ) -> Option { // map of vote counts for every hash at this height let mut current_votes: HashMap = HashMap::new(); let mut total_vote_count = 0; + trace!("Clear winner at block height: {}", block_height); // loop through the latest votes and count all votes // these have already been weighted by balance for (hash, votes) in latest_votes.iter() { - if let Some(ancestor) = self.get_ancestor(*hash, block_height) { + if let Some(ancestor) = self.get_ancestor(*hash, block_height, spec) { let current_vote_value = current_votes.get(&ancestor).unwrap_or_else(|| &0); current_votes.insert(ancestor, current_vote_value + *votes); total_vote_count += votes; @@ -210,54 +201,62 @@ where None } - // Finds the best child, splitting children into a binary tree, based on their hashes + // Finds the best child, splitting children into a binary tree, based on their hashes (Bitwise + // LMD Ghost) fn choose_best_child(&self, votes: &HashMap) -> Option { - let mut bitmask = 0; - for bit in (0..=255).rev() { + if votes.is_empty() { + return None; + } + let mut bitmask: BitVec = BitVec::new(); + // loop through all bits + for bit in 0..=256 { let mut zero_votes = 0; let mut one_votes = 0; - let mut single_candidate = None; + let mut single_candidate = (None, false); + trace!("Child vote length: {}", votes.len()); for (candidate, votes) in votes.iter() { - let candidate_uint = BigEndian::read_u32(candidate); - if candidate_uint >> (bit + 1) != bitmask { + let candidate_bit: BitVec = BitVec::from_bytes(&candidate); + + // if the bitmasks don't match, exclude candidate + if !bitmask.iter().eq(candidate_bit.iter().take(bit)) { + trace!( + "Child: {} was removed in bit: {} with the bitmask: {:?}", + candidate, + bit, + bitmask + ); continue; } - if (candidate_uint >> bit) % 2 == 0 { + if candidate_bit.get(bit) == Some(false) { zero_votes += votes; } else { one_votes += votes; } - if single_candidate.is_none() { - single_candidate = Some(candidate); + if single_candidate.0.is_none() { + single_candidate.0 = Some(candidate); + single_candidate.1 = true; } else { - single_candidate = None; + single_candidate.1 = false; } } - bitmask = (bitmask * 2) + { - if one_votes > zero_votes { - 1 - } else { - 0 - } - }; - if let Some(candidate) = single_candidate { - return Some(*candidate); + bitmask.push(one_votes > zero_votes); + if single_candidate.1 { + return Some(*single_candidate.0.expect("Cannot reach this")); } - //TODO Remove this during benchmark after testing - assert!(bit >= 1); } // should never reach here None } } -impl ForkChoice for OptimisedLMDGhost { +impl ForkChoice for BitwiseLMDGhost { fn add_block( &mut self, block: &BeaconBlock, block_hash: &Hash256, + spec: &ChainSpec, ) -> Result<(), ForkChoiceError> { // get the height of the parent let parent_height = self @@ -265,7 +264,7 @@ impl ForkChoice for OptimisedLMDGhost { .get_deserialized(&block.parent_root)? .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(block.parent_root))? .slot() - .height(Slot::from(GENESIS_SLOT)); + .height(spec.genesis_slot); let parent_hash = &block.parent_root; @@ -295,22 +294,29 @@ impl ForkChoice for OptimisedLMDGhost { &mut self, validator_index: u64, target_block_root: &Hash256, + spec: &ChainSpec, ) -> Result<(), ForkChoiceError> { // simply add the attestation to the latest_attestation_target if the block_height is // larger + trace!( + "Adding attestation of validator: {:?} for block: {}", + validator_index, + target_block_root + ); let attestation_target = self .latest_attestation_targets .entry(validator_index) .or_insert_with(|| *target_block_root); // if we already have a value if attestation_target != target_block_root { + trace!("Old attestation found: {:?}", attestation_target); // get the height of the target block let block_height = self .block_store .get_deserialized(&target_block_root)? .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*target_block_root))? .slot() - .height(Slot::from(GENESIS_SLOT)); + .height(spec.genesis_slot); // get the height of the past target block let past_block_height = self @@ -318,9 +324,10 @@ impl ForkChoice for OptimisedLMDGhost { .get_deserialized(&attestation_target)? .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*attestation_target))? .slot() - .height(Slot::from(GENESIS_SLOT)); + .height(spec.genesis_slot); // update the attestation only if the new target is higher if past_block_height < block_height { + trace!("Updating old attestation"); *attestation_target = *target_block_root; } } @@ -328,25 +335,39 @@ impl ForkChoice for OptimisedLMDGhost { } /// Perform lmd_ghost on the current chain to find the head. - fn find_head(&mut self, justified_block_start: &Hash256) -> Result { + fn find_head( + &mut self, + justified_block_start: &Hash256, + spec: &ChainSpec, + ) -> Result { + debug!( + "Starting optimised fork choice at block: {}", + justified_block_start + ); let block = self .block_store .get_deserialized(&justified_block_start)? .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*justified_block_start))?; let block_slot = block.slot(); - let block_height = block_slot.height(Slot::from(GENESIS_SLOT)); let state_root = block.state_root(); + let mut block_height = block_slot.height(spec.genesis_slot); let mut current_head = *justified_block_start; - let mut latest_votes = self.get_latest_votes(&state_root, block_slot)?; + let mut latest_votes = self.get_latest_votes(&state_root, block_slot, spec)?; // remove any votes that don't relate to our current head. - latest_votes.retain(|hash, _| self.get_ancestor(*hash, block_height) == Some(current_head)); + latest_votes + .retain(|hash, _| self.get_ancestor(*hash, block_height, spec) == Some(current_head)); // begin searching for the head loop { + debug!( + "Iteration for block: {} with vote length: {}", + current_head, + latest_votes.len() + ); // if there are no children, we are done, return the current_head let children = match self.children.get(¤t_head) { Some(children) => children.clone(), @@ -358,9 +379,11 @@ impl ForkChoice for OptimisedLMDGhost { let mut step = power_of_2_below(self.max_known_height.saturating_sub(block_height).as_u32()) / 2; while step > 0 { + trace!("Current Step: {}", step); if let Some(clear_winner) = self.get_clear_winner( &latest_votes, block_height - (block_height % u64::from(step)) + u64::from(step), + spec, ) { current_head = clear_winner; break; @@ -368,17 +391,23 @@ impl ForkChoice for OptimisedLMDGhost { step /= 2; } if step > 0 { + trace!("Found clear winner in log lookup"); } // if our skip lookup failed and we only have one child, progress to that child else if children.len() == 1 { current_head = children[0]; + trace!( + "Lookup failed, only one child, proceeding to child: {}", + current_head + ); } // we need to find the best child path to progress down. else { + trace!("Searching for best child"); let mut child_votes = HashMap::new(); for (voted_hash, vote) in latest_votes.iter() { // if the latest votes correspond to a child - if let Some(child) = self.get_ancestor(*voted_hash, block_height + 1) { + if let Some(child) = self.get_ancestor(*voted_hash, block_height + 1, spec) { // add up the votes for each child *child_votes.entry(child).or_insert_with(|| 0) += vote; } @@ -387,22 +416,30 @@ impl ForkChoice for OptimisedLMDGhost { current_head = self .choose_best_child(&child_votes) .ok_or(ForkChoiceError::CannotFindBestChild)?; + trace!("Best child found: {}", current_head); } - // No head was found, re-iterate - - // update the block height for the next iteration - let block_height = self + // didn't find head yet, proceed to next iteration + // update block height + block_height = self .block_store .get_deserialized(¤t_head)? - .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*justified_block_start))? + .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(current_head))? .slot() - .height(Slot::from(GENESIS_SLOT)); - + .height(spec.genesis_slot); // prune the latest votes for votes that are not part of current chosen chain // more specifically, only keep votes that have head as an ancestor - latest_votes - .retain(|hash, _| self.get_ancestor(*hash, block_height) == Some(current_head)); + for hash in latest_votes.keys() { + trace!( + "Ancestor for vote: {} at height: {} is: {:?}", + hash, + block_height, + self.get_ancestor(*hash, block_height, spec) + ); + } + latest_votes.retain(|hash, _| { + self.get_ancestor(*hash, block_height, spec) == Some(current_head) + }); } } } diff --git a/eth2/fork_choice/src/lib.rs b/eth2/fork_choice/src/lib.rs index c0df820c6..6062c19b1 100644 --- a/eth2/fork_choice/src/lib.rs +++ b/eth2/fork_choice/src/lib.rs @@ -1,57 +1,36 @@ -// Copyright 2019 Sigma Prime Pty Ltd. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the "Software"), -// to deal in the Software without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - //! This crate stores the various implementations of fork-choice rules that can be used for the //! beacon blockchain. //! -//! There are four implementations. One is the naive longest chain rule (primarily for testing -//! purposes). The other three are proposed implementations of the LMD-GHOST fork-choice rule with various forms of optimisation. +//! There are three implementations. One is the naive longest chain rule (primarily for testing +//! purposes). The other two are proposed implementations of the LMD-GHOST fork-choice rule with various forms of optimisation. //! //! The current implementations are: //! - [`longest-chain`]: Simplistic longest-chain fork choice - primarily for testing, **not for //! production**. //! - [`slow_lmd_ghost`]: This is a simple and very inefficient implementation given in the ethereum 2.0 //! specifications (https://github.com/ethereum/eth2.0-specs/blob/v0.1/specs/core/0_beacon-chain.md#get_block_root). -//! - [`optimised_lmd_ghost`]: This is an optimised version of the naive implementation as proposed +//! - [`bitwise_lmd_ghost`]: This is an optimised version of bitwise LMD-GHOST as proposed //! by Vitalik. The reference implementation can be found at: https://github.com/ethereum/research/blob/master/ghost/ghost.py -//! - [`protolambda_lmd_ghost`]: Another optimised version of LMD-GHOST designed by @protolambda. -//! The go implementation can be found here: https://github.com/protolambda/lmd-ghost. //! +//! [`longest-chain`]: struct.LongestChain.html //! [`slow_lmd_ghost`]: struct.SlowLmdGhost.html -//! [`optimised_lmd_ghost`]: struct.OptimisedLmdGhost.html -//! [`protolambda_lmd_ghost`]: struct.ProtolambdaLmdGhost.html +//! [`bitwise_lmd_ghost`]: struct.OptimisedLmdGhost.html extern crate db; extern crate ssz; extern crate types; +pub mod bitwise_lmd_ghost; pub mod longest_chain; -pub mod optimised_lmd_ghost; pub mod slow_lmd_ghost; use db::stores::BeaconBlockAtSlotError; use db::DBError; -use types::{BeaconBlock, Hash256}; +use types::{BeaconBlock, ChainSpec, Hash256}; +pub use bitwise_lmd_ghost::BitwiseLMDGhost; pub use longest_chain::LongestChain; -pub use optimised_lmd_ghost::OptimisedLMDGhost; +pub use slow_lmd_ghost::SlowLMDGhost; /// Defines the interface for Fork Choices. Each Fork choice will define their own data structures /// which can be built in block processing through the `add_block` and `add_attestation` functions. @@ -63,6 +42,7 @@ pub trait ForkChoice: Send + Sync { &mut self, block: &BeaconBlock, block_hash: &Hash256, + spec: &ChainSpec, ) -> Result<(), ForkChoiceError>; /// Called when an attestation has been added. Allows generic attestation-level data structures to be built for a given fork choice. // This can be generalised to a full attestation if required later. @@ -70,10 +50,15 @@ pub trait ForkChoice: Send + Sync { &mut self, validator_index: u64, target_block_hash: &Hash256, + spec: &ChainSpec, ) -> Result<(), ForkChoiceError>; /// The fork-choice algorithm to find the current canonical head of the chain. // TODO: Remove the justified_start_block parameter and make it internal - fn find_head(&mut self, justified_start_block: &Hash256) -> Result; + fn find_head( + &mut self, + justified_start_block: &Hash256, + spec: &ChainSpec, + ) -> Result; } /// Possible fork choice errors that can occur. @@ -109,11 +94,11 @@ impl From for ForkChoiceError { } /// Fork choice options that are currently implemented. -pub enum ForkChoiceAlgorithms { +pub enum ForkChoiceAlgorithm { /// Chooses the longest chain becomes the head. Not for production. LongestChain, /// A simple and highly inefficient implementation of LMD ghost. SlowLMDGhost, - /// An optimised version of LMD-GHOST by Vitalik. - OptimisedLMDGhost, + /// An optimised version of bitwise LMD-GHOST by Vitalik. + BitwiseLMDGhost, } diff --git a/eth2/fork_choice/src/longest_chain.rs b/eth2/fork_choice/src/longest_chain.rs index 8056c11f2..333553c02 100644 --- a/eth2/fork_choice/src/longest_chain.rs +++ b/eth2/fork_choice/src/longest_chain.rs @@ -1,7 +1,7 @@ use crate::{ForkChoice, ForkChoiceError}; use db::{stores::BeaconBlockStore, ClientDB}; use std::sync::Arc; -use types::{BeaconBlock, Hash256, Slot}; +use types::{BeaconBlock, ChainSpec, Hash256, Slot}; pub struct LongestChain where @@ -30,6 +30,7 @@ impl ForkChoice for LongestChain { &mut self, block: &BeaconBlock, block_hash: &Hash256, + _: &ChainSpec, ) -> Result<(), ForkChoiceError> { // add the block hash to head_block_hashes removing the parent if it exists self.head_block_hashes @@ -38,12 +39,17 @@ impl ForkChoice for LongestChain { Ok(()) } - fn add_attestation(&mut self, _: u64, _: &Hash256) -> Result<(), ForkChoiceError> { + fn add_attestation( + &mut self, + _: u64, + _: &Hash256, + _: &ChainSpec, + ) -> Result<(), ForkChoiceError> { // do nothing Ok(()) } - fn find_head(&mut self, _: &Hash256) -> Result { + fn find_head(&mut self, _: &Hash256, _: &ChainSpec) -> Result { let mut head_blocks: Vec<(usize, BeaconBlock)> = vec![]; /* * Load all the head_block hashes from the DB as SszBeaconBlocks. diff --git a/eth2/fork_choice/src/slow_lmd_ghost.rs b/eth2/fork_choice/src/slow_lmd_ghost.rs index 3184150fd..3aafb3924 100644 --- a/eth2/fork_choice/src/slow_lmd_ghost.rs +++ b/eth2/fork_choice/src/slow_lmd_ghost.rs @@ -1,23 +1,3 @@ -// Copyright 2019 Sigma Prime Pty Ltd. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the "Software"), -// to deal in the Software without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - extern crate db; use crate::{ForkChoice, ForkChoiceError}; @@ -25,21 +5,16 @@ use db::{ stores::{BeaconBlockStore, BeaconStateStore}, ClientDB, }; +use log::{debug, trace}; use std::collections::HashMap; use std::sync::Arc; use types::{ readers::BeaconBlockReader, validator_registry::get_active_validator_indices, BeaconBlock, - Hash256, Slot, + ChainSpec, Hash256, Slot, }; //TODO: Pruning and syncing -//TODO: Sort out global constants -const GENESIS_SLOT: u64 = 0; -const FORK_CHOICE_BALANCE_INCREMENT: u64 = 1e9 as u64; -const MAX_DEPOSIT_AMOUNT: u64 = 32e9 as u64; -const EPOCH_LENGTH: u64 = 64; - pub struct SlowLMDGhost { /// The latest attestation targets as a map of validator index to block hash. //TODO: Could this be a fixed size vec @@ -56,12 +31,15 @@ impl SlowLMDGhost where T: ClientDB + Sized, { - pub fn new(block_store: BeaconBlockStore, state_store: BeaconStateStore) -> Self { + pub fn new( + block_store: Arc>, + state_store: Arc>, + ) -> Self { SlowLMDGhost { latest_attestation_targets: HashMap::new(), children: HashMap::new(), - block_store: Arc::new(block_store), - state_store: Arc::new(state_store), + block_store, + state_store, } } @@ -71,6 +49,7 @@ where &self, state_root: &Hash256, block_slot: Slot, + spec: &ChainSpec, ) -> Result, ForkChoiceError> { // get latest votes // Note: Votes are weighted by min(balance, MAX_DEPOSIT_AMOUNT) // @@ -84,21 +63,22 @@ where .ok_or_else(|| ForkChoiceError::MissingBeaconState(*state_root))?; let active_validator_indices = get_active_validator_indices( - ¤t_state.validator_registry, - block_slot.epoch(EPOCH_LENGTH), + ¤t_state.validator_registry[..], + block_slot.epoch(spec.epoch_length), ); for index in active_validator_indices { - let balance = - std::cmp::min(current_state.validator_balances[index], MAX_DEPOSIT_AMOUNT) - / FORK_CHOICE_BALANCE_INCREMENT; + let balance = std::cmp::min( + current_state.validator_balances[index], + spec.max_deposit_amount, + ) / spec.fork_choice_balance_increment; if balance > 0 { if let Some(target) = self.latest_attestation_targets.get(&(index as u64)) { *latest_votes.entry(*target).or_insert_with(|| 0) += balance; } } } - + trace!("Latest votes: {:?}", latest_votes); Ok(latest_votes) } @@ -117,12 +97,12 @@ where .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*block_root))? .slot(); - for (target_hash, votes) in latest_votes.iter() { + for (vote_hash, votes) in latest_votes.iter() { let (root_at_slot, _) = self .block_store - .block_at_slot(&block_root, block_slot)? - .ok_or(ForkChoiceError::MissingBeaconBlock(*block_root))?; - if root_at_slot == *target_hash { + .block_at_slot(&vote_hash, block_slot)? + .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*block_root))?; + if root_at_slot == *block_root { count += votes; } } @@ -136,6 +116,7 @@ impl ForkChoice for SlowLMDGhost { &mut self, block: &BeaconBlock, block_hash: &Hash256, + _: &ChainSpec, ) -> Result<(), ForkChoiceError> { // build the children hashmap // add the new block to the children of parent @@ -153,22 +134,29 @@ impl ForkChoice for SlowLMDGhost { &mut self, validator_index: u64, target_block_root: &Hash256, + spec: &ChainSpec, ) -> Result<(), ForkChoiceError> { // simply add the attestation to the latest_attestation_target if the block_height is // larger + trace!( + "Adding attestation of validator: {:?} for block: {}", + validator_index, + target_block_root + ); let attestation_target = self .latest_attestation_targets .entry(validator_index) .or_insert_with(|| *target_block_root); // if we already have a value if attestation_target != target_block_root { + trace!("Old attestation found: {:?}", attestation_target); // get the height of the target block let block_height = self .block_store .get_deserialized(&target_block_root)? .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*target_block_root))? .slot() - .height(Slot::from(GENESIS_SLOT)); + .height(spec.genesis_slot); // get the height of the past target block let past_block_height = self @@ -176,9 +164,10 @@ impl ForkChoice for SlowLMDGhost { .get_deserialized(&attestation_target)? .ok_or_else(|| ForkChoiceError::MissingBeaconBlock(*attestation_target))? .slot() - .height(Slot::from(GENESIS_SLOT)); + .height(spec.genesis_slot); // update the attestation only if the new target is higher if past_block_height < block_height { + trace!("Updating old attestation"); *attestation_target = *target_block_root; } } @@ -186,7 +175,12 @@ impl ForkChoice for SlowLMDGhost { } /// A very inefficient implementation of LMD ghost. - fn find_head(&mut self, justified_block_start: &Hash256) -> Result { + fn find_head( + &mut self, + justified_block_start: &Hash256, + spec: &ChainSpec, + ) -> Result { + debug!("Running LMD Ghost Fork-choice rule"); let start = self .block_store .get_deserialized(&justified_block_start)? @@ -194,12 +188,12 @@ impl ForkChoice for SlowLMDGhost { let start_state_root = start.state_root(); - let latest_votes = self.get_latest_votes(&start_state_root, start.slot())?; + let latest_votes = self.get_latest_votes(&start_state_root, start.slot(), spec)?; - let mut head_hash = Hash256::zero(); + let mut head_hash = *justified_block_start; loop { - let mut head_vote_count = 0; + debug!("Iteration for block: {}", head_hash); let children = match self.children.get(&head_hash) { Some(children) => children, @@ -207,8 +201,18 @@ impl ForkChoice for SlowLMDGhost { None => break, }; + // if we only have one child, use it + if children.len() == 1 { + trace!("Single child found."); + head_hash = children[0]; + continue; + } + trace!("Children found: {:?}", children); + + let mut head_vote_count = 0; for child_hash in children { let vote_count = self.get_vote_count(&latest_votes, &child_hash)?; + trace!("Vote count for child: {} is: {}", child_hash, vote_count); if vote_count > head_vote_count { head_hash = *child_hash; diff --git a/eth2/fork_choice/tests/bitwise_lmd_ghost_test_vectors.yaml b/eth2/fork_choice/tests/bitwise_lmd_ghost_test_vectors.yaml new file mode 100644 index 000000000..1578673cd --- /dev/null +++ b/eth2/fork_choice/tests/bitwise_lmd_ghost_test_vectors.yaml @@ -0,0 +1,37 @@ +title: Fork-choice Tests +summary: A collection of abstract fork-choice tests for bitwise lmd ghost. +test_suite: Fork-Choice + +test_cases: +- blocks: + - id: 'b0' + parent: 'b0' + - id: 'b1' + parent: 'b0' + - id: 'b2' + parent: 'b1' + - id: 'b3' + parent: 'b1' + weights: + - b0: 0 + - b1: 0 + - b2: 5 + - b3: 10 + heads: + - id: 'b3' +# bitwise LMD ghost example. bitwise GHOST gives b2 +- blocks: + - id: 'b0' + parent: 'b0' + - id: 'b1' + parent: 'b0' + - id: 'b2' + parent: 'b0' + - id: 'b3' + parent: 'b0' + weights: + - b1: 5 + - b2: 4 + - b3: 3 + heads: + - id: 'b2' diff --git a/eth2/fork_choice/tests/lmd_ghost_test_vectors.yaml b/eth2/fork_choice/tests/lmd_ghost_test_vectors.yaml new file mode 100644 index 000000000..4676d8201 --- /dev/null +++ b/eth2/fork_choice/tests/lmd_ghost_test_vectors.yaml @@ -0,0 +1,37 @@ +title: Fork-choice Tests +summary: A collection of abstract fork-choice tests for lmd ghost. +test_suite: Fork-Choice + +test_cases: +- blocks: + - id: 'b0' + parent: 'b0' + - id: 'b1' + parent: 'b0' + - id: 'b2' + parent: 'b1' + - id: 'b3' + parent: 'b1' + weights: + - b0: 0 + - b1: 0 + - b2: 5 + - b3: 10 + heads: + - id: 'b3' +# bitwise LMD ghost example. GHOST gives b1 +- blocks: + - id: 'b0' + parent: 'b0' + - id: 'b1' + parent: 'b0' + - id: 'b2' + parent: 'b0' + - id: 'b3' + parent: 'b0' + weights: + - b1: 5 + - b2: 4 + - b3: 3 + heads: + - id: 'b1' diff --git a/eth2/fork_choice/tests/longest_chain_test_vectors.yaml b/eth2/fork_choice/tests/longest_chain_test_vectors.yaml new file mode 100644 index 000000000..e1cd61f06 --- /dev/null +++ b/eth2/fork_choice/tests/longest_chain_test_vectors.yaml @@ -0,0 +1,51 @@ +title: Fork-choice Tests +summary: A collection of abstract fork-choice tests to verify the longest chain fork-choice rule. +test_suite: Fork-Choice + +test_cases: +- blocks: + - id: 'b0' + parent: 'b0' + - id: 'b1' + parent: 'b0' + - id: 'b2' + parent: 'b1' + - id: 'b3' + parent: 'b1' + - id: 'b4' + parent: 'b3' + weights: + - b0: 0 + - b1: 0 + - b2: 10 + - b3: 1 + heads: + - id: 'b4' +- blocks: + - id: 'b0' + parent: 'b0' + - id: 'b1' + parent: 'b0' + - id: 'b2' + parent: 'b1' + - id: 'b3' + parent: 'b2' + - id: 'b4' + parent: 'b3' + - id: 'b5' + parent: 'b0' + - id: 'b6' + parent: 'b5' + - id: 'b7' + parent: 'b6' + - id: 'b8' + parent: 'b7' + - id: 'b9' + parent: 'b8' + weights: + - b0: 5 + - b1: 20 + - b2: 10 + - b3: 10 + heads: + - id: 'b9' diff --git a/eth2/fork_choice/tests/tests.rs b/eth2/fork_choice/tests/tests.rs new file mode 100644 index 000000000..1d93cd0db --- /dev/null +++ b/eth2/fork_choice/tests/tests.rs @@ -0,0 +1,281 @@ +// Tests the available fork-choice algorithms + +extern crate beacon_chain; +extern crate bls; +extern crate db; +//extern crate env_logger; // for debugging +extern crate fork_choice; +extern crate hex; +extern crate log; +extern crate slot_clock; +extern crate types; +extern crate yaml_rust; + +pub use beacon_chain::BeaconChain; +use bls::{PublicKey, Signature}; +use db::stores::{BeaconBlockStore, BeaconStateStore}; +use db::MemoryDB; +//use env_logger::{Builder, Env}; +use fork_choice::{BitwiseLMDGhost, ForkChoice, ForkChoiceAlgorithm, LongestChain, SlowLMDGhost}; +use ssz::ssz_encode; +use std::collections::HashMap; +use std::sync::Arc; +use std::{fs::File, io::prelude::*, path::PathBuf}; +use types::{ + BeaconBlock, BeaconBlockBody, BeaconState, ChainSpec, Epoch, Eth1Data, Hash256, Slot, Validator, +}; +use yaml_rust::yaml; + +// Note: We Assume the block Id's are hex-encoded. + +#[test] +fn test_bitwise_lmd_ghost() { + // set up logging + //Builder::from_env(Env::default().default_filter_or("trace")).init(); + + test_yaml_vectors( + ForkChoiceAlgorithm::BitwiseLMDGhost, + "tests/bitwise_lmd_ghost_test_vectors.yaml", + 100, + ); +} + +#[test] +fn test_slow_lmd_ghost() { + test_yaml_vectors( + ForkChoiceAlgorithm::SlowLMDGhost, + "tests/lmd_ghost_test_vectors.yaml", + 100, + ); +} + +#[test] +fn test_longest_chain() { + test_yaml_vectors( + ForkChoiceAlgorithm::LongestChain, + "tests/longest_chain_test_vectors.yaml", + 100, + ); +} + +// run a generic test over given YAML test vectors +fn test_yaml_vectors( + fork_choice_algo: ForkChoiceAlgorithm, + yaml_file_path: &str, + emulated_validators: usize, // the number of validators used to give weights. +) { + // load test cases from yaml + let test_cases = load_test_cases_from_yaml(yaml_file_path); + + // default vars + let spec = ChainSpec::foundation(); + let zero_hash = Hash256::zero(); + let eth1_data = Eth1Data { + deposit_root: zero_hash.clone(), + block_hash: zero_hash.clone(), + }; + let randao_reveal = Signature::empty_signature(); + let signature = Signature::empty_signature(); + let body = BeaconBlockBody { + proposer_slashings: vec![], + attester_slashings: vec![], + attestations: vec![], + deposits: vec![], + exits: vec![], + }; + + // process the tests + for test_case in test_cases { + // setup a fresh test + let (mut fork_choice, block_store, state_root) = + setup_inital_state(&fork_choice_algo, emulated_validators); + + // keep a hashmap of block_id's to block_hashes (random hashes to abstract block_id) + //let mut block_id_map: HashMap = HashMap::new(); + // keep a list of hash to slot + let mut block_slot: HashMap = HashMap::new(); + // assume the block tree is given to us in order. + let mut genesis_hash = None; + for block in test_case["blocks"].clone().into_vec().unwrap() { + let block_id = block["id"].as_str().unwrap().to_string(); + let parent_id = block["parent"].as_str().unwrap().to_string(); + + // default params for genesis + let block_hash = id_to_hash(&block_id); + let mut slot = spec.genesis_slot; + let parent_root = id_to_hash(&parent_id); + + // set the slot and parent based off the YAML. Start with genesis; + // if not the genesis, update slot + if parent_id != block_id { + // find parent slot + slot = *(block_slot + .get(&parent_root) + .expect("Parent should have a slot number")) + + 1; + } else { + genesis_hash = Some(block_hash); + } + + // update slot mapping + block_slot.insert(block_hash, slot); + + // build the BeaconBlock + let beacon_block = BeaconBlock { + slot, + parent_root, + state_root: state_root.clone(), + randao_reveal: randao_reveal.clone(), + eth1_data: eth1_data.clone(), + signature: signature.clone(), + body: body.clone(), + }; + + // Store the block. + block_store + .put(&block_hash, &ssz_encode(&beacon_block)[..]) + .unwrap(); + + // run add block for fork choice if not genesis + if parent_id != block_id { + fork_choice + .add_block(&beacon_block, &block_hash, &spec) + .unwrap(); + } + } + + // add the weights (attestations) + let mut current_validator = 0; + for id_map in test_case["weights"].clone().into_vec().unwrap() { + // get the block id and weights + for (map_id, map_weight) in id_map.as_hash().unwrap().iter() { + let id = map_id.as_str().unwrap(); + let block_root = id_to_hash(&id.to_string()); + let weight = map_weight.as_i64().unwrap(); + // we assume a validator has a value 1 and add an attestation for to achieve the + // correct weight + for _ in 0..weight { + assert!( + current_validator <= emulated_validators, + "Not enough validators to emulate weights" + ); + fork_choice + .add_attestation(current_validator as u64, &block_root, &spec) + .unwrap(); + current_validator += 1; + } + } + } + + // everything is set up, run the fork choice, using genesis as the head + let head = fork_choice + .find_head(&genesis_hash.unwrap(), &spec) + .unwrap(); + + // compare the result to the expected test + let success = test_case["heads"] + .clone() + .into_vec() + .unwrap() + .iter() + .find(|heads| id_to_hash(&heads["id"].as_str().unwrap().to_string()) == head) + .is_some(); + + println!("Head found: {}", head); + assert!(success, "Did not find one of the possible heads"); + } +} + +// loads the test_cases from the supplied yaml file +fn load_test_cases_from_yaml(file_path: &str) -> Vec { + // load the yaml + let mut file = { + let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + file_path_buf.push(file_path); + File::open(file_path_buf).unwrap() + }; + let mut yaml_str = String::new(); + file.read_to_string(&mut yaml_str).unwrap(); + let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap(); + let doc = &docs[0]; + doc["test_cases"].as_vec().unwrap().clone() +} + +// initialise a single validator and state. All blocks will reference this state root. +fn setup_inital_state( + fork_choice_algo: &ForkChoiceAlgorithm, + no_validators: usize, +) -> (Box, Arc>, Hash256) { + let zero_hash = Hash256::zero(); + + let db = Arc::new(MemoryDB::open()); + let block_store = Arc::new(BeaconBlockStore::new(db.clone())); + let state_store = Arc::new(BeaconStateStore::new(db.clone())); + + // the fork choice instantiation + let fork_choice: Box = match fork_choice_algo { + ForkChoiceAlgorithm::BitwiseLMDGhost => Box::new(BitwiseLMDGhost::new( + block_store.clone(), + state_store.clone(), + )), + ForkChoiceAlgorithm::SlowLMDGhost => { + Box::new(SlowLMDGhost::new(block_store.clone(), state_store.clone())) + } + ForkChoiceAlgorithm::LongestChain => Box::new(LongestChain::new(block_store.clone())), + }; + + // misc vars for setting up the state + let genesis_time = 1_550_381_159; + + let latest_eth1_data = Eth1Data { + deposit_root: zero_hash.clone(), + block_hash: zero_hash.clone(), + }; + + let initial_validator_deposits = vec![]; + let spec = ChainSpec::foundation(); + + // create the state + let mut state = BeaconState::genesis( + genesis_time, + initial_validator_deposits, + latest_eth1_data, + &spec, + ) + .unwrap(); + + let default_validator = Validator { + pubkey: PublicKey::default(), + withdrawal_credentials: zero_hash, + activation_epoch: Epoch::from(0u64), + exit_epoch: spec.far_future_epoch, + withdrawal_epoch: spec.far_future_epoch, + penalized_epoch: spec.far_future_epoch, + status_flags: None, + }; + // activate the validators + for _ in 0..no_validators { + state.validator_registry.push(default_validator.clone()); + state.validator_balances.push(32_000_000_000); + } + + let state_root = state.canonical_root(); + state_store + .put(&state_root, &ssz_encode(&state)[..]) + .unwrap(); + + // return initialised vars + (fork_choice, block_store, state_root) +} + +// convert a block_id into a Hash256 -- assume input is hex encoded; +fn id_to_hash(id: &String) -> Hash256 { + let bytes = hex::decode(id).expect("Block ID should be hex"); + + let len = std::cmp::min(bytes.len(), 32); + let mut fixed_bytes = [0u8; 32]; + for (index, byte) in bytes.iter().take(32).enumerate() { + fixed_bytes[32 - len + index] = *byte; + } + Hash256::from(fixed_bytes) +} 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/tests.rs b/eth2/types/src/beacon_state/tests.rs index d503d8c6a..a4a43a8ed 100644 --- a/eth2/types/src/beacon_state/tests.rs +++ b/eth2/types/src/beacon_state/tests.rs @@ -7,7 +7,7 @@ use crate::{ 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/slot_epoch_macros.rs b/eth2/types/src/slot_epoch_macros.rs index 54a8f2ce9..b0550f2f8 100644 --- a/eth2/types/src/slot_epoch_macros.rs +++ b/eth2/types/src/slot_epoch_macros.rs @@ -25,12 +25,14 @@ macro_rules! impl_into_u32 { ($main: ident) => { impl Into for $main { fn into(self) -> u32 { + assert!(self.0 < u64::from(std::u32::MAX), "Lossy conversion to u32"); self.0 as u32 } } impl $main { pub fn as_u32(&self) -> u32 { + assert!(self.0 < u64::from(std::u32::MAX), "Lossy conversion to u32"); self.0 as u32 } } 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() +}