Updates to latest master.

eth2/README.md

@@ -0,0 +1,37 @@
+# Ethereum 2.0 Common Crates
+
+Rust crates containing logic common across the Lighthouse project.
+
+## Per-Crate Summary
+
+- [`attester/`](attester/): Core logic for attesting to beacon and shard blocks.
+- [`block_proposer/`](block_proposer/): Core logic for proposing beacon blocks.
+- [`fork_choice/`](fork_choice/): A collection of fork-choice algorithms for
+	the Beacon Chain.
+- [`state_processing/`](state_processing/): Provides per-slot, per-block, and
+	per-epoch state processing.
+- [`types/`](types/): Defines base Ethereum 2.0 types (e.g., `BeaconBlock`,
+	`BeaconState`, etc).
+- [`utils/`](utils/):
+    - [`bls`](utils/bls/): A wrapper for an external BLS encryption library.
+    - [`boolean-bitfield`](utils/boolean-bitfield/): Provides an expandable vector
+		of bools, specifically for use in Eth2.
+    - [`fisher-yates-shuffle`](utils/fisher-yates-shuffle/): shuffles a list
+		pseudo-randomly.
+    - [`hashing`](utils/hashing/): A wrapper for external hashing libraries.
+    - [`honey-badger-split`](utils/honey-badger-split/): Splits a list in `n`
+		parts without giving AF about the length of the list, `n`, or anything
+		else.
+    - [`int-to-bytes`](utils/int-to-bytes/): Simple library which converts ints
+		into byte-strings of various lengths.
+	- [`slot_clock`](utils/slot_clock/): translates the system time into Beacon
+	    Chain "slots". (Also provides another slot clock that's useful during
+		testing.)
+	- [`ssz`](utils/ssz/): an implementation of the SimpleSerialize 
+	    serialization/deserialization protocol used by Eth 2.0.
+	- [`ssz_derive`](utils/ssz_derive/): provides procedural macros for
+		deriving SSZ `Encodable`, `Decodable`, and `TreeHash` methods.
+	- [`swap_or_not_shuffle`](utils/swap_or_not_shuffle/): a list-shuffling
+		method which is slow, but allows for a subset of indices to be shuffled.
+	- [`test_random_derive`](utils/test_random_derive/): provides procedural
+		macros for deriving the `TestRandom` trait defined in `types`.

eth2/attester/src/lib.rs

@@ -2,8 +2,9 @@ pub mod test_utils;
 mod traits;
 
 use slot_clock::SlotClock;
+use ssz::TreeHash;
 use std::sync::Arc;
-use types::{AttestationData, FreeAttestation, Signature, Slot};
+use types::{AttestationData, AttestationDataAndCustodyBit, FreeAttestation, Signature, Slot};
 
 pub use self::traits::{
     BeaconNode, BeaconNodeError, DutiesReader, DutiesReaderError, PublishOutcome, Signer,
@@ -137,10 +138,14 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> Attester<T, U, V,
     fn sign_attestation_data(&mut self, attestation_data: &AttestationData) -> Option<Signature> {
         self.store_produce(attestation_data);
 
-        self.signer.sign_attestation_message(
-            &attestation_data.signable_message(PHASE_0_CUSTODY_BIT)[..],
-            DOMAIN_ATTESTATION,
-        )
+        let message = AttestationDataAndCustodyBit {
+            data: attestation_data.clone(),
+            custody_bit: PHASE_0_CUSTODY_BIT,
+        }
+        .hash_tree_root();
+
+        self.signer
+            .sign_attestation_message(&message[..], DOMAIN_ATTESTATION)
     }
 
     /// Returns `true` if signing some attestation_data is safe (non-slashable).
@@ -195,9 +200,9 @@ mod tests {
         let beacon_node = Arc::new(SimulatedBeaconNode::default());
         let signer = Arc::new(LocalSigner::new(Keypair::random()));
 
-        let mut duties = EpochMap::new(spec.epoch_length);
+        let mut duties = EpochMap::new(spec.slots_per_epoch);
         let attest_slot = Slot::new(100);
-        let attest_epoch = attest_slot / spec.epoch_length;
+        let attest_epoch = attest_slot / spec.slots_per_epoch;
         let attest_shard = 12;
         duties.insert_attestation_shard(attest_slot, attest_shard);
         duties.set_validator_index(Some(2));
@@ -243,7 +248,7 @@ mod tests {
         );
 
         // In an epoch without known duties...
-        let slot = (attest_epoch + 1) * spec.epoch_length;
+        let slot = (attest_epoch + 1) * spec.slots_per_epoch;
         slot_clock.set_slot(slot.into());
         assert_eq!(
             attester.poll(),

eth2/attester/src/test_utils/epoch_map.rs

@@ -3,22 +3,22 @@ use std::collections::HashMap;
 use types::{Epoch, Slot};
 
 pub struct EpochMap {
-    epoch_length: u64,
+    slots_per_epoch: u64,
     validator_index: Option<u64>,
     map: HashMap<Epoch, (Slot, u64)>,
 }
 
 impl EpochMap {
-    pub fn new(epoch_length: u64) -> Self {
+    pub fn new(slots_per_epoch: u64) -> Self {
         Self {
-            epoch_length,
+            slots_per_epoch,
             validator_index: None,
             map: HashMap::new(),
         }
     }
 
     pub fn insert_attestation_shard(&mut self, slot: Slot, shard: u64) {
-        let epoch = slot.epoch(self.epoch_length);
+        let epoch = slot.epoch(self.slots_per_epoch);
         self.map.insert(epoch, (slot, shard));
     }
 
@@ -29,7 +29,7 @@ impl EpochMap {
 
 impl DutiesReader for EpochMap {
     fn attestation_shard(&self, slot: Slot) -> Result<Option<u64>, DutiesReaderError> {
-        let epoch = slot.epoch(self.epoch_length);
+        let epoch = slot.epoch(self.slots_per_epoch);
 
         match self.map.get(&epoch) {
             Some((attest_slot, attest_shard)) if *attest_slot == slot => Ok(Some(*attest_shard)),

eth2/block_proposer/src/lib.rs

@@ -1,10 +1,10 @@
 pub mod test_utils;
 mod traits;
 
-use int_to_bytes::int_to_bytes32;
 use slot_clock::SlotClock;
+use ssz::{SignedRoot, TreeHash};
 use std::sync::Arc;
-use types::{BeaconBlock, ChainSpec, Slot};
+use types::{BeaconBlock, ChainSpec, Domain, Hash256, Proposal, Slot};
 
 pub use self::traits::{
     BeaconNode, BeaconNodeError, DutiesReader, DutiesReaderError, PublishOutcome, Signer,
@@ -28,6 +28,8 @@ pub enum PollOutcome {
     SignerRejection(Slot),
     /// The public key for this validator is not an active validator.
     ValidatorIsUnknown(Slot),
+    /// Unable to determine a `Fork` for signature domain generation.
+    UnableToGetFork(Slot),
 }
 
 #[derive(Debug, PartialEq)]
@@ -130,14 +132,20 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U
     /// The slash-protection code is not yet implemented. There is zero protection against
     /// slashing.
     fn produce_block(&mut self, slot: Slot) -> Result<PollOutcome, Error> {
+        let fork = match self.epoch_map.fork() {
+            Ok(fork) => fork,
+            Err(_) => return Ok(PollOutcome::UnableToGetFork(slot)),
+        };
+
         let randao_reveal = {
             // TODO: add domain, etc to this message. Also ensure result matches `into_to_bytes32`.
-            let message = int_to_bytes32(slot.epoch(self.spec.epoch_length).as_u64());
+            let message = slot.epoch(self.spec.slots_per_epoch).hash_tree_root();
 
-            match self
-                .signer
-                .sign_randao_reveal(&message, self.spec.domain_randao)
-            {
+            match self.signer.sign_randao_reveal(
+                &message,
+                self.spec
+                    .get_domain(slot.epoch(self.spec.slots_per_epoch), Domain::Randao, &fork),
+            ) {
                 None => return Ok(PollOutcome::SignerRejection(slot)),
                 Some(signature) => signature,
             }
@@ -148,7 +156,12 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U
             .produce_beacon_block(slot, &randao_reveal)?
         {
             if self.safe_to_produce(&block) {
-                if let Some(block) = self.sign_block(block) {
+                let domain = self.spec.get_domain(
+                    slot.epoch(self.spec.slots_per_epoch),
+                    Domain::Proposal,
+                    &fork,
+                );
+                if let Some(block) = self.sign_block(block, domain) {
                     self.beacon_node.publish_beacon_block(block)?;
                     Ok(PollOutcome::BlockProduced(slot))
                 } else {
@@ -166,13 +179,20 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U
     ///
     /// Important: this function will not check to ensure the block is not slashable. This must be
     /// done upstream.
-    fn sign_block(&mut self, mut block: BeaconBlock) -> Option<BeaconBlock> {
+    fn sign_block(&mut self, mut block: BeaconBlock, domain: u64) -> Option<BeaconBlock> {
         self.store_produce(&block);
 
-        match self.signer.sign_block_proposal(
-            &block.proposal_root(&self.spec)[..],
-            self.spec.domain_proposal,
-        ) {
+        let proposal = Proposal {
+            slot: block.slot,
+            shard: self.spec.beacon_chain_shard_number,
+            block_root: Hash256::from_slice(&block.signed_root()[..]),
+            signature: block.signature.clone(),
+        };
+
+        match self
+            .signer
+            .sign_block_proposal(&proposal.signed_root()[..], domain)
+        {
             None => None,
             Some(signature) => {
                 block.signature = signature;
@@ -233,9 +253,9 @@ mod tests {
         let beacon_node = Arc::new(SimulatedBeaconNode::default());
         let signer = Arc::new(LocalSigner::new(Keypair::random()));
 
-        let mut epoch_map = EpochMap::new(spec.epoch_length);
+        let mut epoch_map = EpochMap::new(spec.slots_per_epoch);
         let produce_slot = Slot::new(100);
-        let produce_epoch = produce_slot.epoch(spec.epoch_length);
+        let produce_epoch = produce_slot.epoch(spec.slots_per_epoch);
         epoch_map.map.insert(produce_epoch, produce_slot);
         let epoch_map = Arc::new(epoch_map);
 
@@ -280,7 +300,7 @@ mod tests {
         );
 
         // In an epoch without known duties...
-        let slot = (produce_epoch.as_u64() + 1) * spec.epoch_length;
+        let slot = (produce_epoch.as_u64() + 1) * spec.slots_per_epoch;
         slot_clock.set_slot(slot);
         assert_eq!(
             block_proposer.poll(),

eth2/block_proposer/src/test_utils/epoch_map.rs

@@ -1,16 +1,16 @@
 use crate::{DutiesReader, DutiesReaderError};
 use std::collections::HashMap;
-use types::{Epoch, Slot};
+use types::{Epoch, Fork, Slot};
 
 pub struct EpochMap {
-    epoch_length: u64,
+    slots_per_epoch: u64,
     pub map: HashMap<Epoch, Slot>,
 }
 
 impl EpochMap {
-    pub fn new(epoch_length: u64) -> Self {
+    pub fn new(slots_per_epoch: u64) -> Self {
         Self {
-            epoch_length,
+            slots_per_epoch,
             map: HashMap::new(),
         }
     }
@@ -18,11 +18,19 @@ impl EpochMap {
 
 impl DutiesReader for EpochMap {
     fn is_block_production_slot(&self, slot: Slot) -> Result<bool, DutiesReaderError> {
-        let epoch = slot.epoch(self.epoch_length);
+        let epoch = slot.epoch(self.slots_per_epoch);
         match self.map.get(&epoch) {
             Some(s) if *s == slot => Ok(true),
             Some(s) if *s != slot => Ok(false),
             _ => Err(DutiesReaderError::UnknownEpoch),
         }
     }
+
+    fn fork(&self) -> Result<Fork, DutiesReaderError> {
+        Ok(Fork {
+            previous_version: 0,
+            current_version: 0,
+            epoch: Epoch::new(0),
+        })
+    }
 }

eth2/block_proposer/src/traits.rs

@@ -1,4 +1,4 @@
-use types::{BeaconBlock, Signature, Slot};
+use types::{BeaconBlock, Fork, Signature, Slot};
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum BeaconNodeError {
@@ -40,6 +40,7 @@ pub enum DutiesReaderError {
 /// Informs a validator of their duties (e.g., block production).
 pub trait DutiesReader: Send + Sync {
     fn is_block_production_slot(&self, slot: Slot) -> Result<bool, DutiesReaderError>;
+    fn fork(&self) -> Result<Fork, DutiesReaderError>;
 }
 
 /// Signs message using an internally-maintained private key.

eth2/fork_choice/Cargo.toml

@@ -8,7 +8,6 @@ edition = "2018"
 db = { path = "../../beacon_node/db" }
 ssz = { path = "../utils/ssz" }
 types = { path = "../types" }
-fast-math = "0.1.1"
 log = "0.4.6"
 bit-vec = "0.5.0"
 

eth2/fork_choice/src/bitwise_lmd_ghost.rs

@@ -1,5 +1,5 @@
+//! The optimised bitwise LMD-GHOST fork choice rule.
 extern crate bit_vec;
-extern crate fast_math;
 
 use crate::{ForkChoice, ForkChoiceError};
 use bit_vec::BitVec;
@@ -7,7 +7,6 @@ use db::{
     stores::{BeaconBlockStore, BeaconStateStore},
     ClientDB,
 };
-use fast_math::log2_raw;
 use log::{debug, trace};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -19,33 +18,28 @@ use types::{
 //TODO: Pruning - Children
 //TODO: Handle Syncing
 
-/// 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.
-// we use fast log2, a log2 lookup table is implemented in Vitaliks code, potentially do
-// the comparison. Log2_raw takes 2ns according to the documentation.
+// 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.
+
+/// Compute the base-2 logarithm of an integer, floored (rounded down)
 #[inline]
-fn log2_int(x: u32) -> u32 {
+fn log2_int(x: u64) -> 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
+    63 - x.leading_zeros()
 }
 
-fn power_of_2_below(x: u32) -> u32 {
-    2u32.pow(log2_int(x))
+fn power_of_2_below(x: u64) -> u64 {
+    2u64.pow(log2_int(x))
 }
 
 /// Stores the necessary data structures to run the optimised bitwise lmd ghost algorithm.
 pub struct BitwiseLMDGhost<T: ClientDB + Sized> {
     /// A cache of known ancestors at given heights for a specific block.
     //TODO: Consider FnvHashMap
-    cache: HashMap<CacheKey<u32>, Hash256>,
+    cache: HashMap<CacheKey<u64>, Hash256>,
     /// Log lookup table for blocks to their ancestors.
     //TODO: Verify we only want/need a size 16 log lookup
     ancestors: Vec<HashMap<Hash256, Hash256>>,
@@ -101,7 +95,7 @@ where
 
         let active_validator_indices = get_active_validator_indices(
             &current_state.validator_registry[..],
-            block_slot.epoch(spec.epoch_length),
+            block_slot.epoch(spec.slots_per_epoch),
         );
 
         for index in active_validator_indices {
@@ -147,7 +141,7 @@ where
             }
         }
         // check if the result is stored in our cache
-        let cache_key = CacheKey::new(&block_hash, target_height.as_u32());
+        let cache_key = CacheKey::new(&block_hash, target_height.as_u64());
         if let Some(ancestor) = self.cache.get(&cache_key) {
             return Some(*ancestor);
         }
@@ -155,7 +149,7 @@ where
         // 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 - target_height - 1u64).as_u32()) as usize]
+                [log2_int((block_height - target_height - 1u64).as_u64()) 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");
@@ -192,7 +186,7 @@ where
         }
         // Check if there is a clear block winner at this height. If so return it.
         for (hash, votes) in current_votes.iter() {
-            if *votes >= total_vote_count / 2 {
+            if *votes > total_vote_count / 2 {
                 // we have a clear winner, return it
                 return Some(*hash);
             }
@@ -216,7 +210,7 @@ where
 
             trace!("Child vote length: {}", votes.len());
             for (candidate, votes) in votes.iter() {
-                let candidate_bit: BitVec = BitVec::from_bytes(&candidate);
+                let candidate_bit: BitVec = BitVec::from_bytes(candidate.as_bytes());
 
                 // if the bitmasks don't match, exclude candidate
                 if !bitmask.iter().eq(candidate_bit.iter().take(bit)) {
@@ -371,18 +365,21 @@ impl<T: ClientDB + Sized> ForkChoice for BitwiseLMDGhost<T> {
             // if there are no children, we are done, return the current_head
             let children = match self.children.get(&current_head) {
                 Some(children) => children.clone(),
-                None => return Ok(current_head),
+                None => {
+                    debug!("Head found: {}", current_head);
+                    return Ok(current_head);
+                }
             };
 
             // logarithmic lookup blocks to see if there are obvious winners, if so,
             // progress to the next iteration.
             let mut step =
-                power_of_2_below(self.max_known_height.saturating_sub(block_height).as_u32()) / 2;
+                power_of_2_below(self.max_known_height.saturating_sub(block_height).as_u64()) / 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),
+                    block_height - (block_height % step) + step,
                     spec,
                 ) {
                     current_head = clear_winner;
@@ -391,7 +388,7 @@ impl<T: ClientDB + Sized> ForkChoice for BitwiseLMDGhost<T> {
                 step /= 2;
             }
             if step > 0 {
-                trace!("Found clear winner in log lookup");
+                trace!("Found clear winner: {}", current_head);
             }
             // if our skip lookup failed and we only have one child, progress to that child
             else if children.len() == 1 {
@@ -466,7 +463,6 @@ mod tests {
 
     #[test]
     pub fn test_power_of_2_below() {
-        println!("{:?}", std::f32::MAX);
         assert_eq!(power_of_2_below(4), 4);
         assert_eq!(power_of_2_below(5), 4);
         assert_eq!(power_of_2_below(7), 4);
@@ -475,4 +471,12 @@ mod tests {
         assert_eq!(power_of_2_below(33), 32);
         assert_eq!(power_of_2_below(63), 32);
     }
+
+    #[test]
+    pub fn test_power_of_2_below_large() {
+        let pow: u64 = 1 << 24;
+        for x in (pow - 20)..(pow + 20) {
+            assert!(power_of_2_below(x) <= x, "{}", x);
+        }
+    }
 }

eth2/fork_choice/src/slow_lmd_ghost.rs

@@ -64,7 +64,7 @@ where
 
         let active_validator_indices = get_active_validator_indices(
             &current_state.validator_registry[..],
-            block_slot.epoch(spec.epoch_length),
+            block_slot.epoch(spec.slots_per_epoch),
         );
 
         for index in active_validator_indices {

eth2/fork_choice/tests/bitwise_lmd_ghost_test_vectors.yaml

@@ -35,3 +35,31 @@ test_cases:
     - b3: 3
   heads:
     - id: 'b2'
+- blocks:
+    - id: 'b0'
+      parent: 'b0'
+    - id: 'b1'
+      parent: 'b0'
+    - id: 'b2'
+      parent: 'b0'
+    - id: 'b3'
+      parent: 'b1'
+    - id: 'b4'
+      parent: 'b1'
+    - id: 'b5'
+      parent: 'b1'
+    - id: 'b6'
+      parent: 'b2'
+    - id: 'b7'
+      parent: 'b6'
+  weights:
+    - b0: 0
+    - b1: 3
+    - b2: 2
+    - b3: 1
+    - b4: 1
+    - b5: 1
+    - b6: 2
+    - b7: 2
+  heads:
+    - id: 'b4'

eth2/fork_choice/tests/tests.rs

@@ -81,7 +81,8 @@ fn test_yaml_vectors(
         attester_slashings: vec![],
         attestations: vec![],
         deposits: vec![],
-        exits: vec![],
+        voluntary_exits: vec![],
+        transfers: vec![],
     };
 
     // process the tests
@@ -249,9 +250,9 @@ fn setup_inital_state(
         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,
+        withdrawable_epoch: spec.far_future_epoch,
+        initiated_exit: false,
+        slashed: false,
     };
     // activate the validators
     for _ in 0..no_validators {

eth2/state_processing/Cargo.toml

@@ -4,11 +4,22 @@ version = "0.1.0"
 authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"
 
+[[bench]]
+name = "benches"
+harness = false
+
+[dev-dependencies]
+criterion = "0.2"
+env_logger = "0.6.0"
+
 [dependencies]
+bls = { path = "../utils/bls" }
 hashing = { path = "../utils/hashing" }
 int_to_bytes = { path = "../utils/int_to_bytes" }
 integer-sqrt = "0.1"
 log = "0.4"
+merkle_proof = { path = "../utils/merkle_proof" }
 ssz = { path = "../utils/ssz" }
+ssz_derive = { path = "../utils/ssz_derive" }
 types = { path = "../types" }
 rayon = "1.0"

eth2/state_processing/benches/benches.rs

@@ -0,0 +1,65 @@
+use criterion::Criterion;
+use criterion::{black_box, criterion_group, criterion_main, Benchmark};
+// use env_logger::{Builder, Env};
+use state_processing::SlotProcessable;
+use types::beacon_state::BeaconStateBuilder;
+use types::*;
+
+fn epoch_processing(c: &mut Criterion) {
+    // Builder::from_env(Env::default().default_filter_or("debug")).init();
+
+    let mut builder = BeaconStateBuilder::new(16_384);
+
+    builder.build_fast().unwrap();
+    builder.teleport_to_end_of_epoch(builder.spec.genesis_epoch + 4);
+
+    let mut state = builder.cloned_state();
+
+    // Build all the caches so the following state does _not_ include the cache-building time.
+    state
+        .build_epoch_cache(RelativeEpoch::Previous, &builder.spec)
+        .unwrap();
+    state
+        .build_epoch_cache(RelativeEpoch::Current, &builder.spec)
+        .unwrap();
+    state
+        .build_epoch_cache(RelativeEpoch::Next, &builder.spec)
+        .unwrap();
+
+    let cached_state = state.clone();
+
+    // Drop all the caches so the following state includes the cache-building time.
+    state.drop_cache(RelativeEpoch::Previous);
+    state.drop_cache(RelativeEpoch::Current);
+    state.drop_cache(RelativeEpoch::Next);
+
+    let cacheless_state = state;
+
+    let spec_a = builder.spec.clone();
+    let spec_b = builder.spec.clone();
+
+    c.bench(
+        "epoch processing",
+        Benchmark::new("with pre-built caches", move |b| {
+            b.iter_with_setup(
+                || cached_state.clone(),
+                |mut state| black_box(state.per_slot_processing(Hash256::zero(), &spec_a).unwrap()),
+            )
+        })
+        .sample_size(10),
+    );
+
+    c.bench(
+        "epoch processing",
+        Benchmark::new("without pre-built caches", move |b| {
+            b.iter_with_setup(
+                || cacheless_state.clone(),
+                |mut state| black_box(state.per_slot_processing(Hash256::zero(), &spec_b).unwrap()),
+            )
+        })
+        .sample_size(10),
+    );
+}
+
+criterion_group!(benches, epoch_processing,);
+criterion_main!(benches);

eth2/state_processing/src/block_processable.rs

@@ -1,429 +0,0 @@
-use crate::SlotProcessingError;
-use hashing::hash;
-use int_to_bytes::int_to_bytes32;
-use log::{debug, trace};
-use ssz::{ssz_encode, TreeHash};
-use types::{
-    AggregatePublicKey, Attestation, BeaconBlock, BeaconState, BeaconStateError, ChainSpec,
-    Crosslink, Epoch, Exit, Fork, Hash256, PendingAttestation, PublicKey, RelativeEpoch, Signature,
-};
-
-// TODO: define elsehwere.
-const DOMAIN_PROPOSAL: u64 = 2;
-const DOMAIN_EXIT: u64 = 3;
-const DOMAIN_RANDAO: u64 = 4;
-const PHASE_0_CUSTODY_BIT: bool = false;
-const DOMAIN_ATTESTATION: u64 = 1;
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    DBError(String),
-    StateAlreadyTransitioned,
-    PresentSlotIsNone,
-    UnableToDecodeBlock,
-    MissingParentState(Hash256),
-    InvalidParentState(Hash256),
-    MissingBeaconBlock(Hash256),
-    InvalidBeaconBlock(Hash256),
-    MissingParentBlock(Hash256),
-    StateSlotMismatch,
-    BadBlockSignature,
-    BadRandaoSignature,
-    MaxProposerSlashingsExceeded,
-    BadProposerSlashing,
-    MaxAttestationsExceeded,
-    InvalidAttestation(AttestationValidationError),
-    NoBlockRoot,
-    MaxDepositsExceeded,
-    MaxExitsExceeded,
-    BadExit,
-    BadCustodyReseeds,
-    BadCustodyChallenges,
-    BadCustodyResponses,
-    BeaconStateError(BeaconStateError),
-    SlotProcessingError(SlotProcessingError),
-}
-
-#[derive(Debug, PartialEq)]
-pub enum AttestationValidationError {
-    IncludedTooEarly,
-    IncludedTooLate,
-    WrongJustifiedSlot,
-    WrongJustifiedRoot,
-    BadLatestCrosslinkRoot,
-    BadSignature,
-    ShardBlockRootNotZero,
-    NoBlockRoot,
-    BeaconStateError(BeaconStateError),
-}
-
-macro_rules! ensure {
-    ($condition: expr, $result: expr) => {
-        if !$condition {
-            return Err($result);
-        }
-    };
-}
-
-pub trait BlockProcessable {
-    fn per_block_processing(&mut self, block: &BeaconBlock, spec: &ChainSpec) -> Result<(), Error>;
-    fn per_block_processing_without_verifying_block_signature(
-        &mut self,
-        block: &BeaconBlock,
-        spec: &ChainSpec,
-    ) -> Result<(), Error>;
-}
-
-impl BlockProcessable for BeaconState {
-    fn per_block_processing(&mut self, block: &BeaconBlock, spec: &ChainSpec) -> Result<(), Error> {
-        per_block_processing_signature_optional(self, block, true, spec)
-    }
-
-    fn per_block_processing_without_verifying_block_signature(
-        &mut self,
-        block: &BeaconBlock,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        per_block_processing_signature_optional(self, block, false, spec)
-    }
-}
-
-fn per_block_processing_signature_optional(
-    state: &mut BeaconState,
-    block: &BeaconBlock,
-    verify_block_signature: bool,
-    spec: &ChainSpec,
-) -> Result<(), Error> {
-    ensure!(block.slot == state.slot, Error::StateSlotMismatch);
-
-    // Building the previous epoch could be delayed until an attestation from a previous epoch is
-    // included. This is left for future optimisation.
-    state.build_epoch_cache(RelativeEpoch::Previous, spec)?;
-    state.build_epoch_cache(RelativeEpoch::Current, spec)?;
-
-    /*
-     * Proposer Signature
-     */
-    let block_proposer_index = state.get_beacon_proposer_index(block.slot, spec)?;
-    let block_proposer = &state.validator_registry[block_proposer_index];
-
-    if verify_block_signature {
-        ensure!(
-            bls_verify(
-                &block_proposer.pubkey,
-                &block.proposal_root(spec)[..],
-                &block.signature,
-                get_domain(&state.fork, state.current_epoch(spec), DOMAIN_PROPOSAL)
-            ),
-            Error::BadBlockSignature
-        );
-    }
-
-    /*
-     * RANDAO
-     */
-    ensure!(
-        bls_verify(
-            &block_proposer.pubkey,
-            &int_to_bytes32(state.current_epoch(spec).as_u64()),
-            &block.randao_reveal,
-            get_domain(&state.fork, state.current_epoch(spec), DOMAIN_RANDAO)
-        ),
-        Error::BadRandaoSignature
-    );
-
-    // TODO: check this is correct.
-    let new_mix = {
-        let mut mix = state.latest_randao_mixes
-            [state.slot.as_usize() % spec.latest_randao_mixes_length]
-            .to_vec();
-        mix.append(&mut ssz_encode(&block.randao_reveal));
-        Hash256::from(&hash(&mix)[..])
-    };
-
-    state.latest_randao_mixes[state.slot.as_usize() % spec.latest_randao_mixes_length] = new_mix;
-
-    /*
-     * Eth1 data
-     */
-    // TODO: Eth1 data processing.
-
-    /*
-     * Proposer slashings
-     */
-    ensure!(
-        block.body.proposer_slashings.len() as u64 <= spec.max_proposer_slashings,
-        Error::MaxProposerSlashingsExceeded
-    );
-    for proposer_slashing in &block.body.proposer_slashings {
-        let proposer = state
-            .validator_registry
-            .get(proposer_slashing.proposer_index as usize)
-            .ok_or(Error::BadProposerSlashing)?;
-        ensure!(
-            proposer_slashing.proposal_data_1.slot == proposer_slashing.proposal_data_2.slot,
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            proposer_slashing.proposal_data_1.shard == proposer_slashing.proposal_data_2.shard,
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            proposer_slashing.proposal_data_1.block_root
-                != proposer_slashing.proposal_data_2.block_root,
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            proposer.penalized_epoch > state.current_epoch(spec),
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            bls_verify(
-                &proposer.pubkey,
-                &proposer_slashing.proposal_data_1.hash_tree_root(),
-                &proposer_slashing.proposal_signature_1,
-                get_domain(
-                    &state.fork,
-                    proposer_slashing
-                        .proposal_data_1
-                        .slot
-                        .epoch(spec.epoch_length),
-                    DOMAIN_PROPOSAL
-                )
-            ),
-            Error::BadProposerSlashing
-        );
-        ensure!(
-            bls_verify(
-                &proposer.pubkey,
-                &proposer_slashing.proposal_data_2.hash_tree_root(),
-                &proposer_slashing.proposal_signature_2,
-                get_domain(
-                    &state.fork,
-                    proposer_slashing
-                        .proposal_data_2
-                        .slot
-                        .epoch(spec.epoch_length),
-                    DOMAIN_PROPOSAL
-                )
-            ),
-            Error::BadProposerSlashing
-        );
-        state.penalize_validator(proposer_slashing.proposer_index as usize, spec)?;
-    }
-
-    /*
-     * Attestations
-     */
-    ensure!(
-        block.body.attestations.len() as u64 <= spec.max_attestations,
-        Error::MaxAttestationsExceeded
-    );
-
-    debug!("Verifying {} attestations.", block.body.attestations.len());
-
-    for attestation in &block.body.attestations {
-        validate_attestation(&state, attestation, spec)?;
-
-        let pending_attestation = PendingAttestation {
-            data: attestation.data.clone(),
-            aggregation_bitfield: attestation.aggregation_bitfield.clone(),
-            custody_bitfield: attestation.custody_bitfield.clone(),
-            inclusion_slot: state.slot,
-        };
-        state.latest_attestations.push(pending_attestation);
-    }
-
-    /*
-     * Deposits
-     */
-    ensure!(
-        block.body.deposits.len() as u64 <= spec.max_deposits,
-        Error::MaxDepositsExceeded
-    );
-
-    // TODO: process deposits.
-
-    /*
-     * Exits
-     */
-    ensure!(
-        block.body.exits.len() as u64 <= spec.max_exits,
-        Error::MaxExitsExceeded
-    );
-
-    for exit in &block.body.exits {
-        let validator = state
-            .validator_registry
-            .get(exit.validator_index as usize)
-            .ok_or(Error::BadExit)?;
-        ensure!(
-            validator.exit_epoch
-                > state.get_entry_exit_effect_epoch(state.current_epoch(spec), spec),
-            Error::BadExit
-        );
-        ensure!(state.current_epoch(spec) >= exit.epoch, Error::BadExit);
-        let exit_message = {
-            let exit_struct = Exit {
-                epoch: exit.epoch,
-                validator_index: exit.validator_index,
-                signature: spec.empty_signature.clone(),
-            };
-            exit_struct.hash_tree_root()
-        };
-        ensure!(
-            bls_verify(
-                &validator.pubkey,
-                &exit_message,
-                &exit.signature,
-                get_domain(&state.fork, exit.epoch, DOMAIN_EXIT)
-            ),
-            Error::BadProposerSlashing
-        );
-        state.initiate_validator_exit(exit.validator_index as usize);
-    }
-
-    debug!("State transition complete.");
-
-    Ok(())
-}
-
-pub fn validate_attestation(
-    state: &BeaconState,
-    attestation: &Attestation,
-    spec: &ChainSpec,
-) -> Result<(), AttestationValidationError> {
-    validate_attestation_signature_optional(state, attestation, spec, true)
-}
-
-pub fn validate_attestation_without_signature(
-    state: &BeaconState,
-    attestation: &Attestation,
-    spec: &ChainSpec,
-) -> Result<(), AttestationValidationError> {
-    validate_attestation_signature_optional(state, attestation, spec, false)
-}
-
-fn validate_attestation_signature_optional(
-    state: &BeaconState,
-    attestation: &Attestation,
-    spec: &ChainSpec,
-    verify_signature: bool,
-) -> Result<(), AttestationValidationError> {
-    trace!(
-        "validate_attestation_signature_optional: attestation epoch: {}",
-        attestation.data.slot.epoch(spec.epoch_length)
-    );
-    ensure!(
-        attestation.data.slot + spec.min_attestation_inclusion_delay <= state.slot,
-        AttestationValidationError::IncludedTooEarly
-    );
-    ensure!(
-        attestation.data.slot + spec.epoch_length >= state.slot,
-        AttestationValidationError::IncludedTooLate
-    );
-    if attestation.data.slot >= state.current_epoch_start_slot(spec) {
-        ensure!(
-            attestation.data.justified_epoch == state.justified_epoch,
-            AttestationValidationError::WrongJustifiedSlot
-        );
-    } else {
-        ensure!(
-            attestation.data.justified_epoch == state.previous_justified_epoch,
-            AttestationValidationError::WrongJustifiedSlot
-        );
-    }
-    ensure!(
-        attestation.data.justified_block_root
-            == *state
-                .get_block_root(
-                    attestation
-                        .data
-                        .justified_epoch
-                        .start_slot(spec.epoch_length),
-                    &spec
-                )
-                .ok_or(AttestationValidationError::NoBlockRoot)?,
-        AttestationValidationError::WrongJustifiedRoot
-    );
-    let potential_crosslink = Crosslink {
-        shard_block_root: attestation.data.shard_block_root,
-        epoch: attestation.data.slot.epoch(spec.epoch_length),
-    };
-    ensure!(
-        (attestation.data.latest_crosslink
-            == state.latest_crosslinks[attestation.data.shard as usize])
-            | (attestation.data.latest_crosslink == potential_crosslink),
-        AttestationValidationError::BadLatestCrosslinkRoot
-    );
-    if verify_signature {
-        let participants = state.get_attestation_participants(
-            &attestation.data,
-            &attestation.aggregation_bitfield,
-            spec,
-        )?;
-        trace!(
-            "slot: {}, shard: {}, participants: {:?}",
-            attestation.data.slot,
-            attestation.data.shard,
-            participants
-        );
-        let mut group_public_key = AggregatePublicKey::new();
-        for participant in participants {
-            group_public_key.add(
-                state.validator_registry[participant as usize]
-                    .pubkey
-                    .as_raw(),
-            )
-        }
-        ensure!(
-            attestation.verify_signature(
-                &group_public_key,
-                PHASE_0_CUSTODY_BIT,
-                get_domain(
-                    &state.fork,
-                    attestation.data.slot.epoch(spec.epoch_length),
-                    DOMAIN_ATTESTATION,
-                )
-            ),
-            AttestationValidationError::BadSignature
-        );
-    }
-    ensure!(
-        attestation.data.shard_block_root == spec.zero_hash,
-        AttestationValidationError::ShardBlockRootNotZero
-    );
-    Ok(())
-}
-
-fn get_domain(fork: &Fork, epoch: Epoch, domain_type: u64) -> u64 {
-    fork.get_domain(epoch, domain_type)
-}
-
-fn bls_verify(pubkey: &PublicKey, message: &[u8], signature: &Signature, domain: u64) -> bool {
-    signature.verify(message, domain, pubkey)
-}
-
-impl From<AttestationValidationError> for Error {
-    fn from(e: AttestationValidationError) -> Error {
-        Error::InvalidAttestation(e)
-    }
-}
-
-impl From<BeaconStateError> for Error {
-    fn from(e: BeaconStateError) -> Error {
-        Error::BeaconStateError(e)
-    }
-}
-
-impl From<SlotProcessingError> for Error {
-    fn from(e: SlotProcessingError) -> Error {
-        Error::SlotProcessingError(e)
-    }
-}
-
-impl From<BeaconStateError> for AttestationValidationError {
-    fn from(e: BeaconStateError) -> AttestationValidationError {
-        AttestationValidationError::BeaconStateError(e)
-    }
-}

eth2/state_processing/src/epoch_processable.rs

@@ -1,735 +0,0 @@
-use integer_sqrt::IntegerSquareRoot;
-use log::{debug, trace};
-use rayon::prelude::*;
-use ssz::TreeHash;
-use std::collections::{HashMap, HashSet};
-use std::iter::FromIterator;
-use types::{
-    validator_registry::get_active_validator_indices, BeaconState, BeaconStateError, ChainSpec,
-    Crosslink, Epoch, Hash256, InclusionError, PendingAttestation, RelativeEpoch,
-};
-
-macro_rules! safe_add_assign {
-    ($a: expr, $b: expr) => {
-        $a = $a.saturating_add($b);
-    };
-}
-macro_rules! safe_sub_assign {
-    ($a: expr, $b: expr) => {
-        $a = $a.saturating_sub($b);
-    };
-}
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    UnableToDetermineProducer,
-    NoBlockRoots,
-    BaseRewardQuotientIsZero,
-    NoRandaoSeed,
-    BeaconStateError(BeaconStateError),
-    InclusionError(InclusionError),
-    WinningRootError(WinningRootError),
-}
-
-#[derive(Debug, PartialEq)]
-pub enum WinningRootError {
-    NoWinningRoot,
-    BeaconStateError(BeaconStateError),
-}
-
-#[derive(Clone)]
-pub struct WinningRoot {
-    pub shard_block_root: Hash256,
-    pub attesting_validator_indices: Vec<usize>,
-    pub total_balance: u64,
-    pub total_attesting_balance: u64,
-}
-
-pub trait EpochProcessable {
-    fn per_epoch_processing(&mut self, spec: &ChainSpec) -> Result<(), Error>;
-}
-
-impl EpochProcessable for BeaconState {
-    // Cyclomatic complexity is ignored. It would be ideal to split this function apart, however it
-    // remains monolithic to allow for easier spec updates. Once the spec is more stable we can
-    // optimise.
-    #[allow(clippy::cyclomatic_complexity)]
-    fn per_epoch_processing(&mut self, spec: &ChainSpec) -> Result<(), Error> {
-        let current_epoch = self.current_epoch(spec);
-        let previous_epoch = self.previous_epoch(spec);
-        let next_epoch = self.next_epoch(spec);
-
-        debug!(
-            "Starting per-epoch processing on epoch {}...",
-            self.current_epoch(spec)
-        );
-
-        // Ensure all of the caches are built.
-        self.build_epoch_cache(RelativeEpoch::Previous, spec)?;
-        self.build_epoch_cache(RelativeEpoch::Current, spec)?;
-        self.build_epoch_cache(RelativeEpoch::Next, spec)?;
-
-        /*
-         * Validators attesting during the current epoch.
-         */
-        let active_validator_indices = get_active_validator_indices(
-            &self.validator_registry,
-            self.slot.epoch(spec.epoch_length),
-        );
-        let current_total_balance = self.get_total_balance(&active_validator_indices[..], spec);
-
-        trace!(
-            "{} validators with a total balance of {} wei.",
-            active_validator_indices.len(),
-            current_total_balance
-        );
-
-        let current_epoch_attestations: Vec<&PendingAttestation> = self
-            .latest_attestations
-            .par_iter()
-            .filter(|a| {
-                (a.data.slot / spec.epoch_length).epoch(spec.epoch_length)
-                    == self.current_epoch(spec)
-            })
-            .collect();
-
-        trace!(
-            "Current epoch attestations: {}",
-            current_epoch_attestations.len()
-        );
-
-        let current_epoch_boundary_attestations: Vec<&PendingAttestation> =
-            current_epoch_attestations
-                .par_iter()
-                .filter(
-                    |a| match self.get_block_root(self.current_epoch_start_slot(spec), spec) {
-                        Some(block_root) => {
-                            (a.data.epoch_boundary_root == *block_root)
-                                && (a.data.justified_epoch == self.justified_epoch)
-                        }
-                        None => unreachable!(),
-                    },
-                )
-                .cloned()
-                .collect();
-
-        let current_epoch_boundary_attester_indices = self
-            .get_attestation_participants_union(&current_epoch_boundary_attestations[..], spec)?;
-        let current_epoch_boundary_attesting_balance =
-            self.get_total_balance(&current_epoch_boundary_attester_indices[..], spec);
-
-        trace!(
-            "Current epoch boundary attesters: {}",
-            current_epoch_boundary_attester_indices.len()
-        );
-
-        /*
-         * Validators attesting during the previous epoch
-         */
-
-        /*
-         * Validators that made an attestation during the previous epoch
-         */
-        let previous_epoch_attestations: Vec<&PendingAttestation> = self
-            .latest_attestations
-            .par_iter()
-            .filter(|a| {
-                //TODO: ensure these saturating subs are correct.
-                (a.data.slot / spec.epoch_length).epoch(spec.epoch_length)
-                    == self.previous_epoch(spec)
-            })
-            .collect();
-
-        debug!(
-            "previous epoch attestations: {}",
-            previous_epoch_attestations.len()
-        );
-
-        let previous_epoch_attester_indices =
-            self.get_attestation_participants_union(&previous_epoch_attestations[..], spec)?;
-        let previous_total_balance = self.get_total_balance(
-            &get_active_validator_indices(&self.validator_registry, previous_epoch),
-            spec,
-        );
-
-        /*
-         * Validators targetting the previous justified slot
-         */
-        let previous_epoch_justified_attestations: Vec<&PendingAttestation> = {
-            let mut a: Vec<&PendingAttestation> = current_epoch_attestations
-                .iter()
-                .filter(|a| a.data.justified_epoch == self.previous_justified_epoch)
-                .cloned()
-                .collect();
-            let mut b: Vec<&PendingAttestation> = previous_epoch_attestations
-                .iter()
-                .filter(|a| a.data.justified_epoch == self.previous_justified_epoch)
-                .cloned()
-                .collect();
-            a.append(&mut b);
-            a
-        };
-
-        let previous_epoch_justified_attester_indices = self
-            .get_attestation_participants_union(&previous_epoch_justified_attestations[..], spec)?;
-        let previous_epoch_justified_attesting_balance =
-            self.get_total_balance(&previous_epoch_justified_attester_indices[..], spec);
-
-        /*
-         * Validators justifying the epoch boundary block at the start of the previous epoch
-         */
-        let previous_epoch_boundary_attestations: Vec<&PendingAttestation> =
-            previous_epoch_justified_attestations
-                .iter()
-                .filter(
-                    |a| match self.get_block_root(self.previous_epoch_start_slot(spec), spec) {
-                        Some(block_root) => a.data.epoch_boundary_root == *block_root,
-                        None => unreachable!(),
-                    },
-                )
-                .cloned()
-                .collect();
-
-        let previous_epoch_boundary_attester_indices = self
-            .get_attestation_participants_union(&previous_epoch_boundary_attestations[..], spec)?;
-        let previous_epoch_boundary_attesting_balance =
-            self.get_total_balance(&previous_epoch_boundary_attester_indices[..], spec);
-
-        /*
-         * Validators attesting to the expected beacon chain head during the previous epoch.
-         */
-        let previous_epoch_head_attestations: Vec<&PendingAttestation> =
-            previous_epoch_attestations
-                .iter()
-                .filter(|a| match self.get_block_root(a.data.slot, spec) {
-                    Some(block_root) => a.data.beacon_block_root == *block_root,
-                    None => unreachable!(),
-                })
-                .cloned()
-                .collect();
-
-        let previous_epoch_head_attester_indices =
-            self.get_attestation_participants_union(&previous_epoch_head_attestations[..], spec)?;
-        let previous_epoch_head_attesting_balance =
-            self.get_total_balance(&previous_epoch_head_attester_indices[..], spec);
-
-        debug!(
-            "previous_epoch_head_attester_balance of {} wei.",
-            previous_epoch_head_attesting_balance
-        );
-
-        /*
-         * Eth1 Data
-         */
-        if self.next_epoch(spec) % spec.eth1_data_voting_period == 0 {
-            for eth1_data_vote in &self.eth1_data_votes {
-                if eth1_data_vote.vote_count * 2 > spec.eth1_data_voting_period {
-                    self.latest_eth1_data = eth1_data_vote.eth1_data.clone();
-                }
-            }
-            self.eth1_data_votes = vec![];
-        }
-
-        /*
-         * Justification
-         */
-
-        let mut new_justified_epoch = self.justified_epoch;
-        self.justification_bitfield <<= 1;
-
-        // If > 2/3 of the total balance attested to the previous epoch boundary
-        //
-        // - Set the 2nd bit of the bitfield.
-        // - Set the previous epoch to be justified.
-        if (3 * previous_epoch_boundary_attesting_balance) >= (2 * current_total_balance) {
-            self.justification_bitfield |= 2;
-            new_justified_epoch = previous_epoch;
-            trace!(">= 2/3 voted for previous epoch boundary");
-        }
-        // If > 2/3 of the total balance attested to the previous epoch boundary
-        //
-        // - Set the 1st bit of the bitfield.
-        // - Set the current epoch to be justified.
-        if (3 * current_epoch_boundary_attesting_balance) >= (2 * current_total_balance) {
-            self.justification_bitfield |= 1;
-            new_justified_epoch = current_epoch;
-            trace!(">= 2/3 voted for current epoch boundary");
-        }
-
-        // If:
-        //
-        // - All three epochs prior to this epoch have been justified.
-        // - The previous justified justified epoch was three epochs ago.
-        //
-        // Then, set the finalized epoch to be three epochs ago.
-        if ((self.justification_bitfield >> 1) % 8 == 0b111)
-            & (self.previous_justified_epoch == previous_epoch - 2)
-        {
-            self.finalized_epoch = self.previous_justified_epoch;
-            trace!("epoch - 3 was finalized (1st condition).");
-        }
-        // If:
-        //
-        // - Both two epochs prior to this epoch have been justified.
-        // - The previous justified epoch was two epochs ago.
-        //
-        // Then, set the finalized epoch to two epochs ago.
-        if ((self.justification_bitfield >> 1) % 4 == 0b11)
-            & (self.previous_justified_epoch == previous_epoch - 1)
-        {
-            self.finalized_epoch = self.previous_justified_epoch;
-            trace!("epoch - 2 was finalized (2nd condition).");
-        }
-        // If:
-        //
-        // - This epoch and the two prior have been justified.
-        // - The presently justified epoch was two epochs ago.
-        //
-        // Then, set the finalized epoch to two epochs ago.
-        if (self.justification_bitfield % 8 == 0b111) & (self.justified_epoch == previous_epoch - 1)
-        {
-            self.finalized_epoch = self.justified_epoch;
-            trace!("epoch - 2 was finalized (3rd condition).");
-        }
-        // If:
-        //
-        // - This epoch and the epoch prior to it have been justified.
-        // - Set the previous epoch to be justified.
-        //
-        // Then, set the finalized epoch to be the previous epoch.
-        if (self.justification_bitfield % 4 == 0b11) & (self.justified_epoch == previous_epoch) {
-            self.finalized_epoch = self.justified_epoch;
-            trace!("epoch - 1 was finalized (4th condition).");
-        }
-
-        self.previous_justified_epoch = self.justified_epoch;
-        self.justified_epoch = new_justified_epoch;
-
-        debug!(
-            "Finalized epoch {}, justified epoch {}.",
-            self.finalized_epoch, self.justified_epoch
-        );
-
-        /*
-         * Crosslinks
-         */
-
-        // Cached for later lookups.
-        let mut winning_root_for_shards: HashMap<u64, Result<WinningRoot, WinningRootError>> =
-            HashMap::new();
-
-        // for slot in self.slot.saturating_sub(2 * spec.epoch_length)..self.slot {
-        for slot in self.previous_epoch(spec).slot_iter(spec.epoch_length) {
-            trace!(
-                "Finding winning root for slot: {} (epoch: {})",
-                slot,
-                slot.epoch(spec.epoch_length)
-            );
-
-            // Clone is used to remove the borrow. It becomes an issue later when trying to mutate
-            // `self.balances`.
-            let crosslink_committees_at_slot =
-                self.get_crosslink_committees_at_slot(slot, spec)?.clone();
-
-            for (crosslink_committee, shard) in crosslink_committees_at_slot {
-                let shard = shard as u64;
-
-                let winning_root = winning_root(
-                    self,
-                    shard,
-                    &current_epoch_attestations,
-                    &previous_epoch_attestations,
-                    spec,
-                );
-
-                if let Ok(winning_root) = &winning_root {
-                    let total_committee_balance =
-                        self.get_total_balance(&crosslink_committee[..], spec);
-
-                    if (3 * winning_root.total_attesting_balance) >= (2 * total_committee_balance) {
-                        self.latest_crosslinks[shard as usize] = Crosslink {
-                            epoch: current_epoch,
-                            shard_block_root: winning_root.shard_block_root,
-                        }
-                    }
-                }
-                winning_root_for_shards.insert(shard, winning_root);
-            }
-        }
-
-        trace!(
-            "Found {} winning shard roots.",
-            winning_root_for_shards.len()
-        );
-
-        /*
-         * Rewards and Penalities
-         */
-        let base_reward_quotient =
-            previous_total_balance.integer_sqrt() / spec.base_reward_quotient;
-        if base_reward_quotient == 0 {
-            return Err(Error::BaseRewardQuotientIsZero);
-        }
-
-        /*
-         * Justification and finalization
-         */
-        let epochs_since_finality = next_epoch - self.finalized_epoch;
-
-        let previous_epoch_justified_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_justified_attester_indices.iter().cloned());
-        let previous_epoch_boundary_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_boundary_attester_indices.iter().cloned());
-        let previous_epoch_head_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_head_attester_indices.iter().cloned());
-        let previous_epoch_attester_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(previous_epoch_attester_indices.iter().cloned());
-        let active_validator_indices_hashset: HashSet<usize> =
-            HashSet::from_iter(active_validator_indices.iter().cloned());
-
-        debug!("previous epoch justified attesters: {}, previous epoch boundary attesters: {}, previous epoch head attesters: {}, previous epoch attesters: {}", previous_epoch_justified_attester_indices.len(), previous_epoch_boundary_attester_indices.len(), previous_epoch_head_attester_indices.len(), previous_epoch_attester_indices.len());
-
-        debug!("{} epochs since finality.", epochs_since_finality);
-
-        if epochs_since_finality <= 4 {
-            for index in 0..self.validator_balances.len() {
-                let base_reward = self.base_reward(index, base_reward_quotient, spec);
-
-                if previous_epoch_justified_attester_indices_hashset.contains(&index) {
-                    safe_add_assign!(
-                        self.validator_balances[index],
-                        base_reward * previous_epoch_justified_attesting_balance
-                            / previous_total_balance
-                    );
-                } else if active_validator_indices_hashset.contains(&index) {
-                    safe_sub_assign!(self.validator_balances[index], base_reward);
-                }
-
-                if previous_epoch_boundary_attester_indices_hashset.contains(&index) {
-                    safe_add_assign!(
-                        self.validator_balances[index],
-                        base_reward * previous_epoch_boundary_attesting_balance
-                            / previous_total_balance
-                    );
-                } else if active_validator_indices_hashset.contains(&index) {
-                    safe_sub_assign!(self.validator_balances[index], base_reward);
-                }
-
-                if previous_epoch_head_attester_indices_hashset.contains(&index) {
-                    safe_add_assign!(
-                        self.validator_balances[index],
-                        base_reward * previous_epoch_head_attesting_balance
-                            / previous_total_balance
-                    );
-                } else if active_validator_indices_hashset.contains(&index) {
-                    safe_sub_assign!(self.validator_balances[index], base_reward);
-                }
-            }
-
-            for index in previous_epoch_attester_indices {
-                let base_reward = self.base_reward(index, base_reward_quotient, spec);
-                let inclusion_distance =
-                    self.inclusion_distance(&previous_epoch_attestations, index, spec)?;
-
-                safe_add_assign!(
-                    self.validator_balances[index],
-                    base_reward * spec.min_attestation_inclusion_delay / inclusion_distance
-                )
-            }
-        } else {
-            for index in 0..self.validator_balances.len() {
-                let inactivity_penalty = self.inactivity_penalty(
-                    index,
-                    epochs_since_finality,
-                    base_reward_quotient,
-                    spec,
-                );
-                if active_validator_indices_hashset.contains(&index) {
-                    if !previous_epoch_justified_attester_indices_hashset.contains(&index) {
-                        safe_sub_assign!(self.validator_balances[index], inactivity_penalty);
-                    }
-                    if !previous_epoch_boundary_attester_indices_hashset.contains(&index) {
-                        safe_sub_assign!(self.validator_balances[index], inactivity_penalty);
-                    }
-                    if !previous_epoch_head_attester_indices_hashset.contains(&index) {
-                        safe_sub_assign!(self.validator_balances[index], inactivity_penalty);
-                    }
-
-                    if self.validator_registry[index].penalized_epoch <= current_epoch {
-                        let base_reward = self.base_reward(index, base_reward_quotient, spec);
-                        safe_sub_assign!(
-                            self.validator_balances[index],
-                            2 * inactivity_penalty + base_reward
-                        );
-                    }
-                }
-            }
-
-            for index in previous_epoch_attester_indices {
-                let base_reward = self.base_reward(index, base_reward_quotient, spec);
-                let inclusion_distance =
-                    self.inclusion_distance(&previous_epoch_attestations, index, spec)?;
-
-                safe_sub_assign!(
-                    self.validator_balances[index],
-                    base_reward
-                        - base_reward * spec.min_attestation_inclusion_delay / inclusion_distance
-                );
-            }
-        }
-
-        trace!("Processed validator justification and finalization rewards/penalities.");
-
-        /*
-         * Attestation inclusion
-         */
-        for &index in &previous_epoch_attester_indices_hashset {
-            let inclusion_slot =
-                self.inclusion_slot(&previous_epoch_attestations[..], index, spec)?;
-            let proposer_index = self
-                .get_beacon_proposer_index(inclusion_slot, spec)
-                .map_err(|_| Error::UnableToDetermineProducer)?;
-            let base_reward = self.base_reward(proposer_index, base_reward_quotient, spec);
-            safe_add_assign!(
-                self.validator_balances[proposer_index],
-                base_reward / spec.includer_reward_quotient
-            );
-        }
-
-        trace!(
-            "Previous epoch attesters: {}.",
-            previous_epoch_attester_indices_hashset.len()
-        );
-
-        /*
-         * Crosslinks
-         */
-        for slot in self.previous_epoch(spec).slot_iter(spec.epoch_length) {
-            // Clone is used to remove the borrow. It becomes an issue later when trying to mutate
-            // `self.balances`.
-            let crosslink_committees_at_slot =
-                self.get_crosslink_committees_at_slot(slot, spec)?.clone();
-
-            for (_crosslink_committee, shard) in crosslink_committees_at_slot {
-                let shard = shard as u64;
-
-                if let Some(Ok(winning_root)) = winning_root_for_shards.get(&shard) {
-                    // TODO: remove the map.
-                    let attesting_validator_indices: HashSet<usize> = HashSet::from_iter(
-                        winning_root.attesting_validator_indices.iter().cloned(),
-                    );
-
-                    for index in 0..self.validator_balances.len() {
-                        let base_reward = self.base_reward(index, base_reward_quotient, spec);
-
-                        if attesting_validator_indices.contains(&index) {
-                            safe_add_assign!(
-                                self.validator_balances[index],
-                                base_reward * winning_root.total_attesting_balance
-                                    / winning_root.total_balance
-                            );
-                        } else {
-                            safe_sub_assign!(self.validator_balances[index], base_reward);
-                        }
-                    }
-
-                    for index in &winning_root.attesting_validator_indices {
-                        let base_reward = self.base_reward(*index, base_reward_quotient, spec);
-                        safe_add_assign!(
-                            self.validator_balances[*index],
-                            base_reward * winning_root.total_attesting_balance
-                                / winning_root.total_balance
-                        );
-                    }
-                }
-            }
-        }
-
-        /*
-         * Ejections
-         */
-        self.process_ejections(spec);
-
-        /*
-         * Validator Registry
-         */
-        self.previous_calculation_epoch = self.current_calculation_epoch;
-        self.previous_epoch_start_shard = self.current_epoch_start_shard;
-
-        debug!(
-            "setting previous_epoch_seed to : {}",
-            self.current_epoch_seed
-        );
-
-        self.previous_epoch_seed = self.current_epoch_seed;
-
-        let should_update_validator_registy = if self.finalized_epoch
-            > self.validator_registry_update_epoch
-        {
-            (0..self.get_current_epoch_committee_count(spec)).all(|i| {
-                let shard = (self.current_epoch_start_shard + i as u64) % spec.shard_count;
-                self.latest_crosslinks[shard as usize].epoch > self.validator_registry_update_epoch
-            })
-        } else {
-            false
-        };
-
-        if should_update_validator_registy {
-            trace!("updating validator registry.");
-            self.update_validator_registry(spec);
-
-            self.current_calculation_epoch = next_epoch;
-            self.current_epoch_start_shard = (self.current_epoch_start_shard
-                + self.get_current_epoch_committee_count(spec) as u64)
-                % spec.shard_count;
-            self.current_epoch_seed = self.generate_seed(self.current_calculation_epoch, spec)?
-        } else {
-            trace!("not updating validator registry.");
-            let epochs_since_last_registry_update =
-                current_epoch - self.validator_registry_update_epoch;
-            if (epochs_since_last_registry_update > 1)
-                & epochs_since_last_registry_update.is_power_of_two()
-            {
-                self.current_calculation_epoch = next_epoch;
-                self.current_epoch_seed =
-                    self.generate_seed(self.current_calculation_epoch, spec)?
-            }
-        }
-
-        self.process_penalties_and_exits(spec);
-
-        self.latest_index_roots[(next_epoch.as_usize() + spec.entry_exit_delay as usize)
-            % spec.latest_index_roots_length] = hash_tree_root(get_active_validator_indices(
-            &self.validator_registry,
-            next_epoch + Epoch::from(spec.entry_exit_delay),
-        ));
-        self.latest_penalized_balances[next_epoch.as_usize() % spec.latest_penalized_exit_length] =
-            self.latest_penalized_balances
-                [current_epoch.as_usize() % spec.latest_penalized_exit_length];
-        self.latest_randao_mixes[next_epoch.as_usize() % spec.latest_randao_mixes_length] = self
-            .get_randao_mix(current_epoch, spec)
-            .and_then(|x| Some(*x))
-            .ok_or_else(|| Error::NoRandaoSeed)?;
-        self.latest_attestations = self
-            .latest_attestations
-            .iter()
-            .filter(|a| a.data.slot.epoch(spec.epoch_length) >= current_epoch)
-            .cloned()
-            .collect();
-
-        /*
-         * Manage the beacon state caches
-         */
-        self.advance_caches();
-        self.build_epoch_cache(RelativeEpoch::Next, spec)?;
-
-        debug!("Epoch transition complete.");
-
-        Ok(())
-    }
-}
-
-fn hash_tree_root<T: TreeHash>(input: Vec<T>) -> Hash256 {
-    Hash256::from(&input.hash_tree_root()[..])
-}
-
-fn winning_root(
-    state: &BeaconState,
-    shard: u64,
-    current_epoch_attestations: &[&PendingAttestation],
-    previous_epoch_attestations: &[&PendingAttestation],
-    spec: &ChainSpec,
-) -> Result<WinningRoot, WinningRootError> {
-    let mut attestations = current_epoch_attestations.to_vec();
-    attestations.append(&mut previous_epoch_attestations.to_vec());
-
-    let mut candidates: HashMap<Hash256, WinningRoot> = HashMap::new();
-
-    let mut highest_seen_balance = 0;
-
-    for a in &attestations {
-        if a.data.shard != shard {
-            continue;
-        }
-
-        let shard_block_root = &a.data.shard_block_root;
-
-        if candidates.contains_key(shard_block_root) {
-            continue;
-        }
-
-        let attesting_validator_indices = attestations
-            .iter()
-            .try_fold::<_, _, Result<_, BeaconStateError>>(vec![], |mut acc, a| {
-                if (a.data.shard == shard) && (a.data.shard_block_root == *shard_block_root) {
-                    acc.append(&mut state.get_attestation_participants(
-                        &a.data,
-                        &a.aggregation_bitfield,
-                        spec,
-                    )?);
-                }
-                Ok(acc)
-            })?;
-
-        let total_balance: u64 = attesting_validator_indices
-            .iter()
-            .fold(0, |acc, i| acc + state.get_effective_balance(*i, spec));
-
-        let total_attesting_balance: u64 = attesting_validator_indices
-            .iter()
-            .fold(0, |acc, i| acc + state.get_effective_balance(*i, spec));
-
-        if total_attesting_balance > highest_seen_balance {
-            highest_seen_balance = total_attesting_balance;
-        }
-
-        let candidate_root = WinningRoot {
-            shard_block_root: *shard_block_root,
-            attesting_validator_indices,
-            total_attesting_balance,
-            total_balance,
-        };
-
-        candidates.insert(*shard_block_root, candidate_root);
-    }
-
-    Ok(candidates
-        .iter()
-        .filter_map(|(_hash, candidate)| {
-            if candidate.total_attesting_balance == highest_seen_balance {
-                Some(candidate)
-            } else {
-                None
-            }
-        })
-        .min_by_key(|candidate| candidate.shard_block_root)
-        .ok_or_else(|| WinningRootError::NoWinningRoot)?
-        // TODO: avoid clone.
-        .clone())
-}
-
-impl From<InclusionError> for Error {
-    fn from(e: InclusionError) -> Error {
-        Error::InclusionError(e)
-    }
-}
-
-impl From<BeaconStateError> for Error {
-    fn from(e: BeaconStateError) -> Error {
-        Error::BeaconStateError(e)
-    }
-}
-
-impl From<BeaconStateError> for WinningRootError {
-    fn from(e: BeaconStateError) -> WinningRootError {
-        WinningRootError::BeaconStateError(e)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}

eth2/state_processing/src/lib.rs

@@ -1,10 +1,13 @@
-mod block_processable;
-mod epoch_processable;
-mod slot_processable;
+#[macro_use]
+mod macros;
 
-pub use block_processable::{
-    validate_attestation, validate_attestation_without_signature, BlockProcessable,
-    Error as BlockProcessingError,
+pub mod per_block_processing;
+pub mod per_epoch_processing;
+pub mod per_slot_processing;
+
+pub use per_block_processing::{
+    errors::{BlockInvalid, BlockProcessingError},
+    per_block_processing, per_block_processing_without_verifying_block_signature,
 };
-pub use epoch_processable::{EpochProcessable, Error as EpochProcessingError};
-pub use slot_processable::{Error as SlotProcessingError, SlotProcessable};
+pub use per_epoch_processing::{errors::EpochProcessingError, per_epoch_processing};
+pub use per_slot_processing::{per_slot_processing, Error as SlotProcessingError};

eth2/state_processing/src/macros.rs

@@ -0,0 +1,24 @@
+macro_rules! verify {
+    ($condition: expr, $result: expr) => {
+        if !$condition {
+            return Err(Error::Invalid($result));
+        }
+    };
+}
+
+macro_rules! invalid {
+    ($result: expr) => {
+        return Err(Error::Invalid($result));
+    };
+}
+
+macro_rules! safe_add_assign {
+    ($a: expr, $b: expr) => {
+        $a = $a.saturating_add($b);
+    };
+}
+macro_rules! safe_sub_assign {
+    ($a: expr, $b: expr) => {
+        $a = $a.saturating_sub($b);
+    };
+}

eth2/state_processing/src/per_block_processing.rs

@@ -0,0 +1,386 @@
+use self::verify_proposer_slashing::verify_proposer_slashing;
+use errors::{BlockInvalid as Invalid, BlockProcessingError as Error, IntoWithIndex};
+use hashing::hash;
+use log::debug;
+use ssz::{ssz_encode, SignedRoot, TreeHash};
+use types::*;
+
+pub use self::verify_attester_slashing::verify_attester_slashing;
+pub use validate_attestation::{validate_attestation, validate_attestation_without_signature};
+pub use verify_deposit::verify_deposit;
+pub use verify_exit::verify_exit;
+pub use verify_transfer::{execute_transfer, verify_transfer};
+
+pub mod errors;
+mod validate_attestation;
+mod verify_attester_slashing;
+mod verify_deposit;
+mod verify_exit;
+mod verify_proposer_slashing;
+mod verify_slashable_attestation;
+mod verify_transfer;
+
+// Set to `true` to check the merkle proof that a deposit is in the eth1 deposit root.
+//
+// Presently disabled to make testing easier.
+const VERIFY_DEPOSIT_MERKLE_PROOFS: bool = false;
+
+/// Updates the state for a new block, whilst validating that the block is valid.
+///
+/// Returns `Ok(())` if the block is valid and the state was successfully updated. Otherwise
+/// returns an error describing why the block was invalid or how the function failed to execute.
+///
+/// Spec v0.4.0
+pub fn per_block_processing(
+    state: &mut BeaconState,
+    block: &BeaconBlock,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    per_block_processing_signature_optional(state, block, true, spec)
+}
+
+/// Updates the state for a new block, whilst validating that the block is valid, without actually
+/// checking the block proposer signature.
+///
+/// Returns `Ok(())` if the block is valid and the state was successfully updated. Otherwise
+/// returns an error describing why the block was invalid or how the function failed to execute.
+///
+/// Spec v0.4.0
+pub fn per_block_processing_without_verifying_block_signature(
+    state: &mut BeaconState,
+    block: &BeaconBlock,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    per_block_processing_signature_optional(state, block, false, spec)
+}
+
+/// Updates the state for a new block, whilst validating that the block is valid, optionally
+/// checking the block proposer signature.
+///
+/// Returns `Ok(())` if the block is valid and the state was successfully updated. Otherwise
+/// returns an error describing why the block was invalid or how the function failed to execute.
+///
+/// Spec v0.4.0
+fn per_block_processing_signature_optional(
+    mut state: &mut BeaconState,
+    block: &BeaconBlock,
+    should_verify_block_signature: bool,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    // Verify that `block.slot == state.slot`.
+    verify!(block.slot == state.slot, Invalid::StateSlotMismatch);
+
+    // Ensure the current epoch cache is built.
+    state.build_epoch_cache(RelativeEpoch::Current, spec)?;
+
+    if should_verify_block_signature {
+        verify_block_signature(&state, &block, &spec)?;
+    }
+    process_randao(&mut state, &block, &spec)?;
+    process_eth1_data(&mut state, &block.eth1_data)?;
+    process_proposer_slashings(&mut state, &block.body.proposer_slashings[..], spec)?;
+    process_attester_slashings(&mut state, &block.body.attester_slashings[..], spec)?;
+    process_attestations(&mut state, &block.body.attestations[..], spec)?;
+    process_deposits(&mut state, &block.body.deposits[..], spec)?;
+    process_exits(&mut state, &block.body.voluntary_exits[..], spec)?;
+    process_transfers(&mut state, &block.body.transfers[..], spec)?;
+
+    debug!("per_block_processing complete.");
+
+    Ok(())
+}
+
+/// Verifies the signature of a block.
+///
+/// Spec v0.4.0
+pub fn verify_block_signature(
+    state: &BeaconState,
+    block: &BeaconBlock,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let block_proposer =
+        &state.validator_registry[state.get_beacon_proposer_index(block.slot, spec)?];
+
+    let proposal = Proposal {
+        slot: block.slot,
+        shard: spec.beacon_chain_shard_number,
+        block_root: Hash256::from_slice(&block.signed_root()[..]),
+        signature: block.signature.clone(),
+    };
+    let domain = spec.get_domain(
+        block.slot.epoch(spec.slots_per_epoch),
+        Domain::Proposal,
+        &state.fork,
+    );
+
+    verify!(
+        proposal
+            .signature
+            .verify(&proposal.signed_root()[..], domain, &block_proposer.pubkey),
+        Invalid::BadSignature
+    );
+
+    Ok(())
+}
+
+/// Verifies the `randao_reveal` against the block's proposer pubkey and updates
+/// `state.latest_randao_mixes`.
+///
+/// Spec v0.4.0
+pub fn process_randao(
+    state: &mut BeaconState,
+    block: &BeaconBlock,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    // Let `proposer = state.validator_registry[get_beacon_proposer_index(state, state.slot)]`.
+    let block_proposer =
+        &state.validator_registry[state.get_beacon_proposer_index(block.slot, spec)?];
+
+    // Verify that `bls_verify(pubkey=proposer.pubkey,
+    // message_hash=hash_tree_root(get_current_epoch(state)), signature=block.randao_reveal,
+    // domain=get_domain(state.fork, get_current_epoch(state), DOMAIN_RANDAO))`.
+    verify!(
+        block.randao_reveal.verify(
+            &state.current_epoch(spec).hash_tree_root()[..],
+            spec.get_domain(
+                block.slot.epoch(spec.slots_per_epoch),
+                Domain::Randao,
+                &state.fork
+            ),
+            &block_proposer.pubkey
+        ),
+        Invalid::BadRandaoSignature
+    );
+
+    // Update the state's RANDAO mix with the one revealed in the block.
+    update_randao(state, &block.randao_reveal, spec)?;
+
+    Ok(())
+}
+
+/// Update the `state.eth1_data_votes` based upon the `eth1_data` provided.
+///
+/// Spec v0.4.0
+pub fn process_eth1_data(state: &mut BeaconState, eth1_data: &Eth1Data) -> Result<(), Error> {
+    // Either increment the eth1_data vote count, or add a new eth1_data.
+    let matching_eth1_vote_index = state
+        .eth1_data_votes
+        .iter()
+        .position(|vote| vote.eth1_data == *eth1_data);
+    if let Some(index) = matching_eth1_vote_index {
+        state.eth1_data_votes[index].vote_count += 1;
+    } else {
+        state.eth1_data_votes.push(Eth1DataVote {
+            eth1_data: eth1_data.clone(),
+            vote_count: 1,
+        });
+    }
+
+    Ok(())
+}
+
+/// Updates the present randao mix.
+///
+/// Set `state.latest_randao_mixes[get_current_epoch(state) % LATEST_RANDAO_MIXES_LENGTH] =
+/// xor(get_randao_mix(state, get_current_epoch(state)), hash(block.randao_reveal))`.
+///
+/// Spec v0.4.0
+pub fn update_randao(
+    state: &mut BeaconState,
+    reveal: &Signature,
+    spec: &ChainSpec,
+) -> Result<(), BeaconStateError> {
+    let hashed_reveal = {
+        let encoded_signature = ssz_encode(reveal);
+        Hash256::from_slice(&hash(&encoded_signature[..])[..])
+    };
+
+    let current_epoch = state.slot.epoch(spec.slots_per_epoch);
+
+    let current_mix = state
+        .get_randao_mix(current_epoch, spec)
+        .ok_or_else(|| BeaconStateError::InsufficientRandaoMixes)?;
+
+    let new_mix = *current_mix ^ hashed_reveal;
+
+    let index = current_epoch.as_usize() % spec.latest_randao_mixes_length;
+
+    if index < state.latest_randao_mixes.len() {
+        state.latest_randao_mixes[index] = new_mix;
+        Ok(())
+    } else {
+        Err(BeaconStateError::InsufficientRandaoMixes)
+    }
+}
+
+/// Validates each `ProposerSlashing` and updates the state, short-circuiting on an invalid object.
+///
+/// Returns `Ok(())` if the validation and state updates completed successfully, otherwise returns
+/// an `Err` describing the invalid object or cause of failure.
+///
+/// Spec v0.4.0
+pub fn process_proposer_slashings(
+    state: &mut BeaconState,
+    proposer_slashings: &[ProposerSlashing],
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(
+        proposer_slashings.len() as u64 <= spec.max_proposer_slashings,
+        Invalid::MaxProposerSlashingsExceeded
+    );
+    for (i, proposer_slashing) in proposer_slashings.iter().enumerate() {
+        verify_proposer_slashing(proposer_slashing, &state, spec)
+            .map_err(|e| e.into_with_index(i))?;
+        state.slash_validator(proposer_slashing.proposer_index as usize, spec)?;
+    }
+
+    Ok(())
+}
+
+/// Validates each `AttesterSlsashing` and updates the state, short-circuiting on an invalid object.
+///
+/// Returns `Ok(())` if the validation and state updates completed successfully, otherwise returns
+/// an `Err` describing the invalid object or cause of failure.
+///
+/// Spec v0.4.0
+pub fn process_attester_slashings(
+    state: &mut BeaconState,
+    attester_slashings: &[AttesterSlashing],
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(
+        attester_slashings.len() as u64 <= spec.max_attester_slashings,
+        Invalid::MaxAttesterSlashingsExceed
+    );
+    for (i, attester_slashing) in attester_slashings.iter().enumerate() {
+        let slashable_indices = verify_attester_slashing(&state, &attester_slashing, spec)
+            .map_err(|e| e.into_with_index(i))?;
+        for i in slashable_indices {
+            state.slash_validator(i as usize, spec)?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Validates each `Attestation` and updates the state, short-circuiting on an invalid object.
+///
+/// Returns `Ok(())` if the validation and state updates completed successfully, otherwise returns
+/// an `Err` describing the invalid object or cause of failure.
+///
+/// Spec v0.4.0
+pub fn process_attestations(
+    state: &mut BeaconState,
+    attestations: &[Attestation],
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(
+        attestations.len() as u64 <= spec.max_attestations,
+        Invalid::MaxAttestationsExceeded
+    );
+    for (i, attestation) in attestations.iter().enumerate() {
+        // Build the previous epoch cache only if required by an attestation.
+        if attestation.data.slot.epoch(spec.slots_per_epoch) == state.previous_epoch(spec) {
+            state.build_epoch_cache(RelativeEpoch::Previous, spec)?;
+        }
+
+        validate_attestation(state, attestation, spec).map_err(|e| e.into_with_index(i))?;
+
+        let pending_attestation = PendingAttestation {
+            data: attestation.data.clone(),
+            aggregation_bitfield: attestation.aggregation_bitfield.clone(),
+            custody_bitfield: attestation.custody_bitfield.clone(),
+            inclusion_slot: state.slot,
+        };
+        state.latest_attestations.push(pending_attestation);
+    }
+
+    Ok(())
+}
+
+/// Validates each `Deposit` and updates the state, short-circuiting on an invalid object.
+///
+/// Returns `Ok(())` if the validation and state updates completed successfully, otherwise returns
+/// an `Err` describing the invalid object or cause of failure.
+///
+/// Spec v0.4.0
+pub fn process_deposits(
+    state: &mut BeaconState,
+    deposits: &[Deposit],
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(
+        deposits.len() as u64 <= spec.max_deposits,
+        Invalid::MaxDepositsExceeded
+    );
+    for (i, deposit) in deposits.iter().enumerate() {
+        verify_deposit(state, deposit, VERIFY_DEPOSIT_MERKLE_PROOFS, spec)
+            .map_err(|e| e.into_with_index(i))?;
+
+        state
+            .process_deposit(
+                deposit.deposit_data.deposit_input.pubkey.clone(),
+                deposit.deposit_data.amount,
+                deposit
+                    .deposit_data
+                    .deposit_input
+                    .proof_of_possession
+                    .clone(),
+                deposit.deposit_data.deposit_input.withdrawal_credentials,
+                None,
+                spec,
+            )
+            .map_err(|_| Error::Invalid(Invalid::DepositProcessingFailed(i)))?;
+
+        state.deposit_index += 1;
+    }
+
+    Ok(())
+}
+
+/// Validates each `Exit` and updates the state, short-circuiting on an invalid object.
+///
+/// Returns `Ok(())` if the validation and state updates completed successfully, otherwise returns
+/// an `Err` describing the invalid object or cause of failure.
+///
+/// Spec v0.4.0
+pub fn process_exits(
+    state: &mut BeaconState,
+    voluntary_exits: &[VoluntaryExit],
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(
+        voluntary_exits.len() as u64 <= spec.max_voluntary_exits,
+        Invalid::MaxExitsExceeded
+    );
+    for (i, exit) in voluntary_exits.iter().enumerate() {
+        verify_exit(&state, exit, spec).map_err(|e| e.into_with_index(i))?;
+
+        state.initiate_validator_exit(exit.validator_index as usize);
+    }
+
+    Ok(())
+}
+
+/// Validates each `Transfer` and updates the state, short-circuiting on an invalid object.
+///
+/// Returns `Ok(())` if the validation and state updates completed successfully, otherwise returns
+/// an `Err` describing the invalid object or cause of failure.
+///
+/// Spec v0.4.0
+pub fn process_transfers(
+    state: &mut BeaconState,
+    transfers: &[Transfer],
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(
+        transfers.len() as u64 <= spec.max_transfers,
+        Invalid::MaxTransfersExceed
+    );
+    for (i, transfer) in transfers.iter().enumerate() {
+        verify_transfer(&state, transfer, spec).map_err(|e| e.into_with_index(i))?;
+        execute_transfer(state, transfer, spec).map_err(|e| e.into_with_index(i))?;
+    }
+
+    Ok(())
+}

eth2/state_processing/src/per_block_processing/errors.rs

@@ -0,0 +1,387 @@
+use types::*;
+
+macro_rules! impl_from_beacon_state_error {
+    ($type: ident) => {
+        impl From<BeaconStateError> for $type {
+            fn from(e: BeaconStateError) -> $type {
+                $type::BeaconStateError(e)
+            }
+        }
+    };
+}
+
+macro_rules! impl_into_with_index_with_beacon_error {
+    ($error_type: ident, $invalid_type: ident) => {
+        impl IntoWithIndex<BlockProcessingError> for $error_type {
+            fn into_with_index(self, i: usize) -> BlockProcessingError {
+                match self {
+                    $error_type::Invalid(e) => {
+                        BlockProcessingError::Invalid(BlockInvalid::$invalid_type(i, e))
+                    }
+                    $error_type::BeaconStateError(e) => BlockProcessingError::BeaconStateError(e),
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_into_with_index_without_beacon_error {
+    ($error_type: ident, $invalid_type: ident) => {
+        impl IntoWithIndex<BlockProcessingError> for $error_type {
+            fn into_with_index(self, i: usize) -> BlockProcessingError {
+                match self {
+                    $error_type::Invalid(e) => {
+                        BlockProcessingError::Invalid(BlockInvalid::$invalid_type(i, e))
+                    }
+                }
+            }
+        }
+    };
+}
+
+/// A conversion that consumes `self` and adds an `index` variable to resulting struct.
+///
+/// Used here to allow converting an error into an upstream error that points to the object that
+/// caused the error. For example, pointing to the index of an attestation that caused the
+/// `AttestationInvalid` error.
+pub trait IntoWithIndex<T>: Sized {
+    fn into_with_index(self, index: usize) -> T;
+}
+
+/*
+ * Block Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum BlockProcessingError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(BlockInvalid),
+    /// Encountered a `BeaconStateError` whilst attempting to determine validity.
+    BeaconStateError(BeaconStateError),
+}
+
+impl_from_beacon_state_error!(BlockProcessingError);
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum BlockInvalid {
+    StateSlotMismatch,
+    BadSignature,
+    BadRandaoSignature,
+    MaxAttestationsExceeded,
+    MaxAttesterSlashingsExceed,
+    MaxProposerSlashingsExceeded,
+    MaxDepositsExceeded,
+    MaxExitsExceeded,
+    MaxTransfersExceed,
+    AttestationInvalid(usize, AttestationInvalid),
+    AttesterSlashingInvalid(usize, AttesterSlashingInvalid),
+    ProposerSlashingInvalid(usize, ProposerSlashingInvalid),
+    DepositInvalid(usize, DepositInvalid),
+    // TODO: merge this into the `DepositInvalid` error.
+    DepositProcessingFailed(usize),
+    ExitInvalid(usize, ExitInvalid),
+    TransferInvalid(usize, TransferInvalid),
+}
+
+impl Into<BlockProcessingError> for BlockInvalid {
+    fn into(self) -> BlockProcessingError {
+        BlockProcessingError::Invalid(self)
+    }
+}
+
+/*
+ * Attestation Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum AttestationValidationError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(AttestationInvalid),
+    /// Encountered a `BeaconStateError` whilst attempting to determine validity.
+    BeaconStateError(BeaconStateError),
+}
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum AttestationInvalid {
+    /// Attestation references a pre-genesis slot.
+    ///
+    /// (genesis_slot, attestation_slot)
+    PreGenesis(Slot, Slot),
+    /// Attestation included before the inclusion delay.
+    ///
+    /// (state_slot, inclusion_delay, attestation_slot)
+    IncludedTooEarly(Slot, u64, Slot),
+    /// Attestation slot is too far in the past to be included in a block.
+    ///
+    /// (state_slot, attestation_slot)
+    IncludedTooLate(Slot, Slot),
+    /// Attestation justified epoch does not match the states current or previous justified epoch.
+    ///
+    /// (attestation_justified_epoch, state_epoch, used_previous_epoch)
+    WrongJustifiedEpoch(Epoch, Epoch, bool),
+    /// Attestation justified epoch root does not match root known to the state.
+    ///
+    /// (state_justified_root, attestation_justified_root)
+    WrongJustifiedRoot(Hash256, Hash256),
+    /// Attestation crosslink root does not match the state crosslink root for the attestations
+    /// slot.
+    BadLatestCrosslinkRoot,
+    /// The custody bitfield has some bits set `true`. This is not allowed in phase 0.
+    CustodyBitfieldHasSetBits,
+    /// There are no set bits on the attestation -- an attestation must be signed by at least one
+    /// validator.
+    AggregationBitfieldIsEmpty,
+    /// The custody bitfield length is not the smallest possible size to represent the committee.
+    ///
+    /// (committee_len, bitfield_len)
+    BadCustodyBitfieldLength(usize, usize),
+    /// The aggregation bitfield length is not the smallest possible size to represent the committee.
+    ///
+    /// (committee_len, bitfield_len)
+    BadAggregationBitfieldLength(usize, usize),
+    /// There was no known committee for the given shard in the given slot.
+    ///
+    /// (attestation_data_shard, attestation_data_slot)
+    NoCommitteeForShard(u64, Slot),
+    /// The attestation signature verification failed.
+    BadSignature,
+    /// The shard block root was not set to zero. This is a phase 0 requirement.
+    ShardBlockRootNotZero,
+}
+
+impl_from_beacon_state_error!(AttestationValidationError);
+impl_into_with_index_with_beacon_error!(AttestationValidationError, AttestationInvalid);
+
+/*
+ * `AttesterSlashing` Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum AttesterSlashingValidationError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(AttesterSlashingInvalid),
+    /// Encountered a `BeaconStateError` whilst attempting to determine validity.
+    BeaconStateError(BeaconStateError),
+}
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum AttesterSlashingInvalid {
+    /// The attestation data is identical, an attestation cannot conflict with itself.
+    AttestationDataIdentical,
+    /// The attestations were not in conflict.
+    NotSlashable,
+    /// The first `SlashableAttestation` was invalid.
+    SlashableAttestation1Invalid(SlashableAttestationInvalid),
+    /// The second `SlashableAttestation` was invalid.
+    SlashableAttestation2Invalid(SlashableAttestationInvalid),
+    /// The validator index is unknown. One cannot slash one who does not exist.
+    UnknownValidator(u64),
+    /// There were no indices able to be slashed.
+    NoSlashableIndices,
+}
+
+impl_from_beacon_state_error!(AttesterSlashingValidationError);
+impl_into_with_index_with_beacon_error!(AttesterSlashingValidationError, AttesterSlashingInvalid);
+
+/*
+ * `SlashableAttestation` Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum SlashableAttestationValidationError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(SlashableAttestationInvalid),
+}
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum SlashableAttestationInvalid {
+    /// The custody bitfield has some bits set `true`. This is not allowed in phase 0.
+    CustodyBitfieldHasSetBits,
+    /// No validator indices were specified.
+    NoValidatorIndices,
+    /// The validator indices were not in increasing order.
+    ///
+    /// The error occured between the given `index` and `index + 1`
+    BadValidatorIndicesOrdering(usize),
+    /// The custody bitfield length is not the smallest possible size to represent the validators.
+    ///
+    /// (validators_len, bitfield_len)
+    BadCustodyBitfieldLength(usize, usize),
+    /// The number of slashable indices exceed the global maximum.
+    ///
+    /// (max_indices, indices_given)
+    MaxIndicesExceed(usize, usize),
+    /// The validator index is unknown. One cannot slash one who does not exist.
+    UnknownValidator(u64),
+    /// The slashable attestation aggregate signature was not valid.
+    BadSignature,
+}
+
+impl Into<SlashableAttestationInvalid> for SlashableAttestationValidationError {
+    fn into(self) -> SlashableAttestationInvalid {
+        match self {
+            SlashableAttestationValidationError::Invalid(e) => e,
+        }
+    }
+}
+
+/*
+ * `ProposerSlashing` Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum ProposerSlashingValidationError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(ProposerSlashingInvalid),
+}
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum ProposerSlashingInvalid {
+    /// The proposer index is not a known validator.
+    ProposerUnknown(u64),
+    /// The two proposal have different slots.
+    ///
+    /// (proposal_1_slot, proposal_2_slot)
+    ProposalSlotMismatch(Slot, Slot),
+    /// The two proposal have different shards.
+    ///
+    /// (proposal_1_shard, proposal_2_shard)
+    ProposalShardMismatch(u64, u64),
+    /// The two proposal have different block roots.
+    ///
+    /// (proposal_1_root, proposal_2_root)
+    ProposalBlockRootMismatch(Hash256, Hash256),
+    /// The specified proposer has already been slashed.
+    ProposerAlreadySlashed,
+    /// The first proposal signature was invalid.
+    BadProposal1Signature,
+    /// The second proposal signature was invalid.
+    BadProposal2Signature,
+}
+
+impl_into_with_index_without_beacon_error!(
+    ProposerSlashingValidationError,
+    ProposerSlashingInvalid
+);
+
+/*
+ * `Deposit` Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum DepositValidationError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(DepositInvalid),
+}
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum DepositInvalid {
+    /// The deposit index does not match the state index.
+    ///
+    /// (state_index, deposit_index)
+    BadIndex(u64, u64),
+    /// The specified `branch` and `index` did not form a valid proof that the deposit is included
+    /// in the eth1 deposit root.
+    BadMerkleProof,
+}
+
+impl_into_with_index_without_beacon_error!(DepositValidationError, DepositInvalid);
+
+/*
+ * `Exit` Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum ExitValidationError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(ExitInvalid),
+}
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum ExitInvalid {
+    /// The specified validator is not in the state's validator registry.
+    ValidatorUnknown(u64),
+    AlreadyExited,
+    /// The exit is for a future epoch.
+    ///
+    /// (state_epoch, exit_epoch)
+    FutureEpoch(Epoch, Epoch),
+    /// The exit signature was not signed by the validator.
+    BadSignature,
+}
+
+impl_into_with_index_without_beacon_error!(ExitValidationError, ExitInvalid);
+
+/*
+ * `Transfer` Validation
+ */
+
+/// The object is invalid or validation failed.
+#[derive(Debug, PartialEq)]
+pub enum TransferValidationError {
+    /// Validation completed successfully and the object is invalid.
+    Invalid(TransferInvalid),
+    /// Encountered a `BeaconStateError` whilst attempting to determine validity.
+    BeaconStateError(BeaconStateError),
+}
+
+/// Describes why an object is invalid.
+#[derive(Debug, PartialEq)]
+pub enum TransferInvalid {
+    /// The validator indicated by `transfer.from` is unknown.
+    FromValidatorUnknown(u64),
+    /// The validator indicated by `transfer.to` is unknown.
+    ToValidatorUnknown(u64),
+    /// The balance of `transfer.from` is insufficient.
+    ///
+    /// (required, available)
+    FromBalanceInsufficient(u64, u64),
+    /// Adding `transfer.fee` to `transfer.amount` causes an overflow.
+    ///
+    /// (transfer_fee, transfer_amount)
+    FeeOverflow(u64, u64),
+    /// This transfer would result in the `transfer.from` account to have `0 < balance <
+    /// min_deposit_amount`
+    ///
+    /// (resulting_amount, min_deposit_amount)
+    InvalidResultingFromBalance(u64, u64),
+    /// The state slot does not match `transfer.slot`.
+    ///
+    /// (state_slot, transfer_slot)
+    StateSlotMismatch(Slot, Slot),
+    /// The `transfer.from` validator has been activated and is not withdrawable.
+    ///
+    /// (from_validator)
+    FromValidatorIneligableForTransfer(u64),
+    /// The validators withdrawal credentials do not match `transfer.pubkey`.
+    ///
+    /// (state_credentials, transfer_pubkey_credentials)
+    WithdrawalCredentialsMismatch(Hash256, Hash256),
+    /// The deposit was not signed by `deposit.pubkey`.
+    BadSignature,
+    /// Overflow when adding to `transfer.to` balance.
+    ///
+    /// (to_balance, transfer_amount)
+    ToBalanceOverflow(u64, u64),
+    /// Overflow when adding to beacon proposer balance.
+    ///
+    /// (proposer_balance, transfer_fee)
+    ProposerBalanceOverflow(u64, u64),
+}
+
+impl_from_beacon_state_error!(TransferValidationError);
+impl_into_with_index_with_beacon_error!(TransferValidationError, TransferInvalid);

eth2/state_processing/src/per_block_processing/validate_attestation.rs

@@ -0,0 +1,255 @@
+use super::errors::{AttestationInvalid as Invalid, AttestationValidationError as Error};
+use ssz::TreeHash;
+use types::beacon_state::helpers::*;
+use types::*;
+
+/// Indicates if an `Attestation` is valid to be included in a block in the current epoch of the
+/// given state.
+///
+/// Returns `Ok(())` if the `Attestation` is valid, otherwise indicates the reason for invalidity.
+///
+/// Spec v0.4.0
+pub fn validate_attestation(
+    state: &BeaconState,
+    attestation: &Attestation,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    validate_attestation_signature_optional(state, attestation, spec, true)
+}
+
+/// Indicates if an `Attestation` is valid to be included in a block in the current epoch of the
+/// given state, without validating the aggregate signature.
+///
+/// Returns `Ok(())` if the `Attestation` is valid, otherwise indicates the reason for invalidity.
+///
+/// Spec v0.4.0
+pub fn validate_attestation_without_signature(
+    state: &BeaconState,
+    attestation: &Attestation,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    validate_attestation_signature_optional(state, attestation, spec, false)
+}
+
+/// Indicates if an `Attestation` is valid to be included in a block in the current epoch of the
+/// given state, optionally validating the aggregate signature.
+///
+///
+/// Spec v0.4.0
+fn validate_attestation_signature_optional(
+    state: &BeaconState,
+    attestation: &Attestation,
+    spec: &ChainSpec,
+    verify_signature: bool,
+) -> Result<(), Error> {
+    // Verify that `attestation.data.slot >= GENESIS_SLOT`.
+    verify!(
+        attestation.data.slot >= spec.genesis_slot,
+        Invalid::PreGenesis(spec.genesis_slot, attestation.data.slot)
+    );
+
+    // Verify that `attestation.data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= state.slot`.
+    verify!(
+        attestation.data.slot + spec.min_attestation_inclusion_delay <= state.slot,
+        Invalid::IncludedTooEarly(
+            state.slot,
+            spec.min_attestation_inclusion_delay,
+            attestation.data.slot
+        )
+    );
+
+    // Verify that `state.slot < attestation.data.slot + SLOTS_PER_EPOCH`.
+    verify!(
+        state.slot < attestation.data.slot + spec.slots_per_epoch,
+        Invalid::IncludedTooLate(state.slot, attestation.data.slot)
+    );
+
+    // Verify that `attestation.data.justified_epoch` is equal to `state.justified_epoch` if
+    // `slot_to_epoch(attestation.data.slot + 1) >= get_current_epoch(state) else
+    // state.previous_justified_epoch`.
+    if (attestation.data.slot + 1).epoch(spec.slots_per_epoch) >= state.current_epoch(spec) {
+        verify!(
+            attestation.data.justified_epoch == state.justified_epoch,
+            Invalid::WrongJustifiedEpoch(
+                attestation.data.justified_epoch,
+                state.justified_epoch,
+                false
+            )
+        );
+    } else {
+        verify!(
+            attestation.data.justified_epoch == state.previous_justified_epoch,
+            Invalid::WrongJustifiedEpoch(
+                attestation.data.justified_epoch,
+                state.previous_justified_epoch,
+                true
+            )
+        );
+    }
+
+    // Verify that `attestation.data.justified_block_root` is equal to `get_block_root(state,
+    // get_epoch_start_slot(attestation.data.justified_epoch))`.
+    let justified_block_root = *state
+        .get_block_root(
+            attestation
+                .data
+                .justified_epoch
+                .start_slot(spec.slots_per_epoch),
+            &spec,
+        )
+        .ok_or(BeaconStateError::InsufficientBlockRoots)?;
+    verify!(
+        attestation.data.justified_block_root == justified_block_root,
+        Invalid::WrongJustifiedRoot(justified_block_root, attestation.data.justified_block_root)
+    );
+
+    // Verify that either:
+    //
+    // (i)`state.latest_crosslinks[attestation.data.shard] == attestation.data.latest_crosslink`,
+    //
+    // (ii) `state.latest_crosslinks[attestation.data.shard] ==
+    // Crosslink(crosslink_data_root=attestation.data.crosslink_data_root,
+    // epoch=slot_to_epoch(attestation.data.slot))`.
+    let potential_crosslink = Crosslink {
+        crosslink_data_root: attestation.data.crosslink_data_root,
+        epoch: attestation.data.slot.epoch(spec.slots_per_epoch),
+    };
+    verify!(
+        (attestation.data.latest_crosslink
+            == state.latest_crosslinks[attestation.data.shard as usize])
+            | (state.latest_crosslinks[attestation.data.shard as usize] == potential_crosslink),
+        Invalid::BadLatestCrosslinkRoot
+    );
+
+    // Get the committee for this attestation
+    let (committee, _shard) = state
+        .get_crosslink_committees_at_slot(attestation.data.slot, spec)?
+        .iter()
+        .find(|(_committee, shard)| *shard == attestation.data.shard)
+        .ok_or_else(|| {
+            Error::Invalid(Invalid::NoCommitteeForShard(
+                attestation.data.shard,
+                attestation.data.slot,
+            ))
+        })?;
+
+    // Custody bitfield is all zeros (phase 0 requirement).
+    verify!(
+        attestation.custody_bitfield.num_set_bits() == 0,
+        Invalid::CustodyBitfieldHasSetBits
+    );
+    // Custody bitfield length is correct.
+    verify!(
+        verify_bitfield_length(&attestation.custody_bitfield, committee.len()),
+        Invalid::BadCustodyBitfieldLength(committee.len(), attestation.custody_bitfield.len())
+    );
+    // Aggregation bitfield isn't empty.
+    verify!(
+        attestation.aggregation_bitfield.num_set_bits() != 0,
+        Invalid::AggregationBitfieldIsEmpty
+    );
+    // Aggregation bitfield length is correct.
+    verify!(
+        verify_bitfield_length(&attestation.aggregation_bitfield, committee.len()),
+        Invalid::BadAggregationBitfieldLength(
+            committee.len(),
+            attestation.aggregation_bitfield.len()
+        )
+    );
+
+    if verify_signature {
+        let attestation_epoch = attestation.data.slot.epoch(spec.slots_per_epoch);
+        verify!(
+            verify_attestation_signature(
+                state,
+                committee,
+                attestation_epoch,
+                &attestation.custody_bitfield,
+                &attestation.data,
+                &attestation.aggregate_signature,
+                spec
+            ),
+            Invalid::BadSignature
+        );
+    }
+
+    // [TO BE REMOVED IN PHASE 1] Verify that `attestation.data.crosslink_data_root == ZERO_HASH`.
+    verify!(
+        attestation.data.crosslink_data_root == spec.zero_hash,
+        Invalid::ShardBlockRootNotZero
+    );
+
+    Ok(())
+}
+
+/// Verifies an aggregate signature for some given `AttestationData`, returning `true` if the
+/// `aggregate_signature` is valid.
+///
+/// Returns `false` if:
+///  - `aggregate_signature` was not signed correctly.
+///  - `custody_bitfield` does not have a bit for each index of `committee`.
+///  - A `validator_index` in `committee` is not in `state.validator_registry`.
+///
+/// Spec v0.4.0
+fn verify_attestation_signature(
+    state: &BeaconState,
+    committee: &[usize],
+    attestation_epoch: Epoch,
+    custody_bitfield: &Bitfield,
+    attestation_data: &AttestationData,
+    aggregate_signature: &AggregateSignature,
+    spec: &ChainSpec,
+) -> bool {
+    let mut aggregate_pubs = vec![AggregatePublicKey::new(); 2];
+    let mut message_exists = vec![false; 2];
+
+    for (i, v) in committee.iter().enumerate() {
+        let custody_bit = match custody_bitfield.get(i) {
+            Ok(bit) => bit,
+            // Invalidate signature if custody_bitfield.len() < committee
+            Err(_) => return false,
+        };
+
+        message_exists[custody_bit as usize] = true;
+
+        match state.validator_registry.get(*v as usize) {
+            Some(validator) => {
+                aggregate_pubs[custody_bit as usize].add(&validator.pubkey);
+            }
+            // Invalidate signature if validator index is unknown.
+            None => return false,
+        };
+    }
+
+    // Message when custody bitfield is `false`
+    let message_0 = AttestationDataAndCustodyBit {
+        data: attestation_data.clone(),
+        custody_bit: false,
+    }
+    .hash_tree_root();
+
+    // Message when custody bitfield is `true`
+    let message_1 = AttestationDataAndCustodyBit {
+        data: attestation_data.clone(),
+        custody_bit: true,
+    }
+    .hash_tree_root();
+
+    let mut messages = vec![];
+    let mut keys = vec![];
+
+    // If any validator signed a message with a `false` custody bit.
+    if message_exists[0] {
+        messages.push(&message_0[..]);
+        keys.push(&aggregate_pubs[0]);
+    }
+    // If any validator signed a message with a `true` custody bit.
+    if message_exists[1] {
+        messages.push(&message_1[..]);
+        keys.push(&aggregate_pubs[1]);
+    }
+
+    let domain = spec.get_domain(attestation_epoch, Domain::Attestation, &state.fork);
+
+    aggregate_signature.verify_multiple(&messages[..], domain, &keys[..])
+}

eth2/state_processing/src/per_block_processing/verify_attester_slashing.rs

@@ -0,0 +1,49 @@
+use super::errors::{AttesterSlashingInvalid as Invalid, AttesterSlashingValidationError as Error};
+use super::verify_slashable_attestation::verify_slashable_attestation;
+use types::*;
+
+/// Indicates if an `AttesterSlashing` is valid to be included in a block in the current epoch of the given
+/// state.
+///
+/// Returns `Ok(())` if the `AttesterSlashing` is valid, otherwise indicates the reason for invalidity.
+///
+/// Spec v0.4.0
+pub fn verify_attester_slashing(
+    state: &BeaconState,
+    attester_slashing: &AttesterSlashing,
+    spec: &ChainSpec,
+) -> Result<Vec<u64>, Error> {
+    let slashable_attestation_1 = &attester_slashing.slashable_attestation_1;
+    let slashable_attestation_2 = &attester_slashing.slashable_attestation_2;
+
+    verify!(
+        slashable_attestation_1.data != slashable_attestation_2.data,
+        Invalid::AttestationDataIdentical
+    );
+    verify!(
+        slashable_attestation_1.is_double_vote(slashable_attestation_2, spec)
+            | slashable_attestation_1.is_surround_vote(slashable_attestation_2, spec),
+        Invalid::NotSlashable
+    );
+
+    verify_slashable_attestation(state, &slashable_attestation_1, spec)
+        .map_err(|e| Error::Invalid(Invalid::SlashableAttestation1Invalid(e.into())))?;
+    verify_slashable_attestation(state, &slashable_attestation_2, spec)
+        .map_err(|e| Error::Invalid(Invalid::SlashableAttestation2Invalid(e.into())))?;
+
+    let mut slashable_indices = vec![];
+    for i in &slashable_attestation_1.validator_indices {
+        let validator = state
+            .validator_registry
+            .get(*i as usize)
+            .ok_or_else(|| Error::Invalid(Invalid::UnknownValidator(*i)))?;
+
+        if slashable_attestation_1.validator_indices.contains(&i) & !validator.slashed {
+            slashable_indices.push(*i);
+        }
+    }
+
+    verify!(!slashable_indices.is_empty(), Invalid::NoSlashableIndices);
+
+    Ok(slashable_indices)
+}

eth2/state_processing/src/per_block_processing/verify_deposit.rs

@@ -0,0 +1,73 @@
+use super::errors::{DepositInvalid as Invalid, DepositValidationError as Error};
+use hashing::hash;
+use merkle_proof::verify_merkle_proof;
+use ssz::ssz_encode;
+use ssz_derive::Encode;
+use types::*;
+
+/// Indicates if a `Deposit` is valid to be included in a block in the current epoch of the given
+/// state.
+///
+/// Returns `Ok(())` if the `Deposit` is valid, otherwise indicates the reason for invalidity.
+///
+/// Note: this function is incomplete.
+///
+/// Spec v0.4.0
+pub fn verify_deposit(
+    state: &BeaconState,
+    deposit: &Deposit,
+    verify_merkle_branch: bool,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    verify!(
+        deposit.index == state.deposit_index,
+        Invalid::BadIndex(state.deposit_index, deposit.index)
+    );
+
+    if verify_merkle_branch {
+        verify!(
+            verify_deposit_merkle_proof(state, deposit, spec),
+            Invalid::BadMerkleProof
+        );
+    }
+
+    Ok(())
+}
+
+/// Verify that a deposit is included in the state's eth1 deposit root.
+///
+/// Spec v0.4.0
+fn verify_deposit_merkle_proof(state: &BeaconState, deposit: &Deposit, spec: &ChainSpec) -> bool {
+    let leaf = hash(&get_serialized_deposit_data(deposit));
+    verify_merkle_proof(
+        Hash256::from_slice(&leaf),
+        &deposit.branch,
+        spec.deposit_contract_tree_depth as usize,
+        deposit.index as usize,
+        state.latest_eth1_data.deposit_root,
+    )
+}
+
+/// Helper struct for easily getting the serialized data generated by the deposit contract.
+///
+/// Spec v0.4.0
+#[derive(Encode)]
+struct SerializedDepositData {
+    amount: u64,
+    timestamp: u64,
+    input: DepositInput,
+}
+
+/// Return the serialized data generated by the deposit contract that is used to generate the
+/// merkle proof.
+///
+/// Spec v0.4.0
+fn get_serialized_deposit_data(deposit: &Deposit) -> Vec<u8> {
+    let serialized_deposit_data = SerializedDepositData {
+        amount: deposit.deposit_data.amount,
+        timestamp: deposit.deposit_data.timestamp,
+        input: deposit.deposit_data.deposit_input.clone(),
+    };
+
+    ssz_encode(&serialized_deposit_data)
+}

eth2/state_processing/src/per_block_processing/verify_exit.rs

@@ -0,0 +1,42 @@
+use super::errors::{ExitInvalid as Invalid, ExitValidationError as Error};
+use ssz::SignedRoot;
+use types::*;
+
+/// Indicates if an `Exit` is valid to be included in a block in the current epoch of the given
+/// state.
+///
+/// Returns `Ok(())` if the `Exit` is valid, otherwise indicates the reason for invalidity.
+///
+/// Spec v0.4.0
+pub fn verify_exit(
+    state: &BeaconState,
+    exit: &VoluntaryExit,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let validator = state
+        .validator_registry
+        .get(exit.validator_index as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::ValidatorUnknown(exit.validator_index)))?;
+
+    verify!(
+        validator.exit_epoch
+            > state.get_delayed_activation_exit_epoch(state.current_epoch(spec), spec),
+        Invalid::AlreadyExited
+    );
+
+    verify!(
+        state.current_epoch(spec) >= exit.epoch,
+        Invalid::FutureEpoch(state.current_epoch(spec), exit.epoch)
+    );
+
+    let message = exit.signed_root();
+    let domain = spec.get_domain(exit.epoch, Domain::Exit, &state.fork);
+
+    verify!(
+        exit.signature
+            .verify(&message[..], domain, &validator.pubkey),
+        Invalid::BadSignature
+    );
+
+    Ok(())
+}

eth2/state_processing/src/per_block_processing/verify_proposer_slashing.rs

@@ -0,0 +1,87 @@
+use super::errors::{ProposerSlashingInvalid as Invalid, ProposerSlashingValidationError as Error};
+use ssz::SignedRoot;
+use types::*;
+
+/// Indicates if a `ProposerSlashing` is valid to be included in a block in the current epoch of the given
+/// state.
+///
+/// Returns `Ok(())` if the `ProposerSlashing` is valid, otherwise indicates the reason for invalidity.
+///
+/// Spec v0.4.0
+pub fn verify_proposer_slashing(
+    proposer_slashing: &ProposerSlashing,
+    state: &BeaconState,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let proposer = state
+        .validator_registry
+        .get(proposer_slashing.proposer_index as usize)
+        .ok_or_else(|| {
+            Error::Invalid(Invalid::ProposerUnknown(proposer_slashing.proposer_index))
+        })?;
+
+    verify!(
+        proposer_slashing.proposal_1.slot == proposer_slashing.proposal_2.slot,
+        Invalid::ProposalSlotMismatch(
+            proposer_slashing.proposal_1.slot,
+            proposer_slashing.proposal_2.slot
+        )
+    );
+
+    verify!(
+        proposer_slashing.proposal_1.shard == proposer_slashing.proposal_2.shard,
+        Invalid::ProposalShardMismatch(
+            proposer_slashing.proposal_1.shard,
+            proposer_slashing.proposal_2.shard
+        )
+    );
+
+    verify!(
+        proposer_slashing.proposal_1.block_root != proposer_slashing.proposal_2.block_root,
+        Invalid::ProposalBlockRootMismatch(
+            proposer_slashing.proposal_1.block_root,
+            proposer_slashing.proposal_2.block_root
+        )
+    );
+
+    verify!(!proposer.slashed, Invalid::ProposerAlreadySlashed);
+
+    verify!(
+        verify_proposal_signature(
+            &proposer_slashing.proposal_1,
+            &proposer.pubkey,
+            &state.fork,
+            spec
+        ),
+        Invalid::BadProposal1Signature
+    );
+    verify!(
+        verify_proposal_signature(
+            &proposer_slashing.proposal_2,
+            &proposer.pubkey,
+            &state.fork,
+            spec
+        ),
+        Invalid::BadProposal2Signature
+    );
+
+    Ok(())
+}
+
+/// Verifies the signature of a proposal.
+///
+/// Returns `true` if the signature is valid.
+fn verify_proposal_signature(
+    proposal: &Proposal,
+    pubkey: &PublicKey,
+    fork: &Fork,
+    spec: &ChainSpec,
+) -> bool {
+    let message = proposal.signed_root();
+    let domain = spec.get_domain(
+        proposal.slot.epoch(spec.slots_per_epoch),
+        Domain::Proposal,
+        fork,
+    );
+    proposal.signature.verify(&message[..], domain, pubkey)
+}

eth2/state_processing/src/per_block_processing/verify_slashable_attestation.rs

@@ -0,0 +1,112 @@
+use super::errors::{
+    SlashableAttestationInvalid as Invalid, SlashableAttestationValidationError as Error,
+};
+use ssz::TreeHash;
+use types::beacon_state::helpers::verify_bitfield_length;
+use types::*;
+
+/// Indicates if a `SlashableAttestation` is valid to be included in a block in the current epoch of the given
+/// state.
+///
+/// Returns `Ok(())` if the `SlashableAttestation` is valid, otherwise indicates the reason for invalidity.
+///
+/// Spec v0.4.0
+pub fn verify_slashable_attestation(
+    state: &BeaconState,
+    slashable_attestation: &SlashableAttestation,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    if slashable_attestation.custody_bitfield.num_set_bits() > 0 {
+        invalid!(Invalid::CustodyBitfieldHasSetBits);
+    }
+
+    if slashable_attestation.validator_indices.is_empty() {
+        invalid!(Invalid::NoValidatorIndices);
+    }
+
+    for i in 0..(slashable_attestation.validator_indices.len() - 1) {
+        if slashable_attestation.validator_indices[i]
+            >= slashable_attestation.validator_indices[i + 1]
+        {
+            invalid!(Invalid::BadValidatorIndicesOrdering(i));
+        }
+    }
+
+    if !verify_bitfield_length(
+        &slashable_attestation.custody_bitfield,
+        slashable_attestation.validator_indices.len(),
+    ) {
+        invalid!(Invalid::BadCustodyBitfieldLength(
+            slashable_attestation.validator_indices.len(),
+            slashable_attestation.custody_bitfield.len()
+        ));
+    }
+
+    if slashable_attestation.validator_indices.len() > spec.max_indices_per_slashable_vote as usize
+    {
+        invalid!(Invalid::MaxIndicesExceed(
+            spec.max_indices_per_slashable_vote as usize,
+            slashable_attestation.validator_indices.len()
+        ));
+    }
+
+    // TODO: this signature verification could likely be replaced with:
+    //
+    // super::validate_attestation::validate_attestation_signature(..)
+
+    let mut aggregate_pubs = vec![AggregatePublicKey::new(); 2];
+    let mut message_exists = vec![false; 2];
+
+    for (i, v) in slashable_attestation.validator_indices.iter().enumerate() {
+        let custody_bit = match slashable_attestation.custody_bitfield.get(i) {
+            Ok(bit) => bit,
+            Err(_) => unreachable!(),
+        };
+
+        message_exists[custody_bit as usize] = true;
+
+        match state.validator_registry.get(*v as usize) {
+            Some(validator) => {
+                aggregate_pubs[custody_bit as usize].add(&validator.pubkey);
+            }
+            None => invalid!(Invalid::UnknownValidator(*v)),
+        };
+    }
+
+    let message_0 = AttestationDataAndCustodyBit {
+        data: slashable_attestation.data.clone(),
+        custody_bit: false,
+    }
+    .hash_tree_root();
+    let message_1 = AttestationDataAndCustodyBit {
+        data: slashable_attestation.data.clone(),
+        custody_bit: true,
+    }
+    .hash_tree_root();
+
+    let mut messages = vec![];
+    let mut keys = vec![];
+
+    if message_exists[0] {
+        messages.push(&message_0[..]);
+        keys.push(&aggregate_pubs[0]);
+    }
+    if message_exists[1] {
+        messages.push(&message_1[..]);
+        keys.push(&aggregate_pubs[1]);
+    }
+
+    let domain = {
+        let epoch = slashable_attestation.data.slot.epoch(spec.slots_per_epoch);
+        spec.get_domain(epoch, Domain::Attestation, &state.fork)
+    };
+
+    verify!(
+        slashable_attestation
+            .aggregate_signature
+            .verify_multiple(&messages[..], domain, &keys[..]),
+        Invalid::BadSignature
+    );
+
+    Ok(())
+}

eth2/state_processing/src/per_block_processing/verify_transfer.rs

@@ -0,0 +1,135 @@
+use super::errors::{TransferInvalid as Invalid, TransferValidationError as Error};
+use bls::get_withdrawal_credentials;
+use ssz::SignedRoot;
+use types::*;
+
+/// Indicates if a `Transfer` is valid to be included in a block in the current epoch of the given
+/// state.
+///
+/// Returns `Ok(())` if the `Transfer` is valid, otherwise indicates the reason for invalidity.
+///
+/// Note: this function is incomplete.
+///
+/// Spec v0.4.0
+pub fn verify_transfer(
+    state: &BeaconState,
+    transfer: &Transfer,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let from_balance = *state
+        .validator_balances
+        .get(transfer.from as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.from)))?;
+
+    let total_amount = transfer
+        .amount
+        .checked_add(transfer.fee)
+        .ok_or_else(|| Error::Invalid(Invalid::FeeOverflow(transfer.amount, transfer.fee)))?;
+
+    verify!(
+        from_balance >= transfer.amount,
+        Invalid::FromBalanceInsufficient(transfer.amount, from_balance)
+    );
+
+    verify!(
+        from_balance >= transfer.fee,
+        Invalid::FromBalanceInsufficient(transfer.fee, from_balance)
+    );
+
+    verify!(
+        (from_balance == total_amount)
+            || (from_balance >= (total_amount + spec.min_deposit_amount)),
+        Invalid::InvalidResultingFromBalance(from_balance - total_amount, spec.min_deposit_amount)
+    );
+
+    verify!(
+        state.slot == transfer.slot,
+        Invalid::StateSlotMismatch(state.slot, transfer.slot)
+    );
+
+    let from_validator = state
+        .validator_registry
+        .get(transfer.from as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.from)))?;
+    let epoch = state.slot.epoch(spec.slots_per_epoch);
+
+    verify!(
+        from_validator.is_withdrawable_at(epoch)
+            || from_validator.activation_epoch == spec.far_future_epoch,
+        Invalid::FromValidatorIneligableForTransfer(transfer.from)
+    );
+
+    let transfer_withdrawal_credentials = Hash256::from_slice(
+        &get_withdrawal_credentials(&transfer.pubkey, spec.bls_withdrawal_prefix_byte)[..],
+    );
+    verify!(
+        from_validator.withdrawal_credentials == transfer_withdrawal_credentials,
+        Invalid::WithdrawalCredentialsMismatch(
+            from_validator.withdrawal_credentials,
+            transfer_withdrawal_credentials
+        )
+    );
+
+    let message = transfer.signed_root();
+    let domain = spec.get_domain(
+        transfer.slot.epoch(spec.slots_per_epoch),
+        Domain::Transfer,
+        &state.fork,
+    );
+
+    verify!(
+        transfer
+            .signature
+            .verify(&message[..], domain, &transfer.pubkey),
+        Invalid::BadSignature
+    );
+
+    Ok(())
+}
+
+/// Executes a transfer on the state.
+///
+/// Does not check that the transfer is valid, however checks for overflow in all actions.
+///
+/// Spec v0.4.0
+pub fn execute_transfer(
+    state: &mut BeaconState,
+    transfer: &Transfer,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let from_balance = *state
+        .validator_balances
+        .get(transfer.from as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::FromValidatorUnknown(transfer.from)))?;
+    let to_balance = *state
+        .validator_balances
+        .get(transfer.to as usize)
+        .ok_or_else(|| Error::Invalid(Invalid::ToValidatorUnknown(transfer.to)))?;
+
+    let proposer_index = state.get_beacon_proposer_index(state.slot, spec)?;
+    let proposer_balance = state.validator_balances[proposer_index];
+
+    let total_amount = transfer
+        .amount
+        .checked_add(transfer.fee)
+        .ok_or_else(|| Error::Invalid(Invalid::FeeOverflow(transfer.amount, transfer.fee)))?;
+
+    state.validator_balances[transfer.from as usize] =
+        from_balance.checked_sub(total_amount).ok_or_else(|| {
+            Error::Invalid(Invalid::FromBalanceInsufficient(total_amount, from_balance))
+        })?;
+
+    state.validator_balances[transfer.to as usize] = to_balance
+        .checked_add(transfer.amount)
+        .ok_or_else(|| Error::Invalid(Invalid::ToBalanceOverflow(to_balance, transfer.amount)))?;
+
+    state.validator_balances[proposer_index] =
+        proposer_balance.checked_add(transfer.fee).ok_or_else(|| {
+            Error::Invalid(Invalid::ProposerBalanceOverflow(
+                proposer_balance,
+                transfer.fee,
+            ))
+        })?;
+
+    Ok(())
+}

eth2/state_processing/src/per_epoch_processing.rs

@@ -0,0 +1,491 @@
+use attester_sets::AttesterSets;
+use errors::EpochProcessingError as Error;
+use inclusion_distance::{inclusion_distance, inclusion_slot};
+use integer_sqrt::IntegerSquareRoot;
+use log::debug;
+use rayon::prelude::*;
+use ssz::TreeHash;
+use std::collections::{HashMap, HashSet};
+use std::iter::FromIterator;
+use types::{validator_registry::get_active_validator_indices, *};
+use winning_root::{winning_root, WinningRoot};
+
+pub mod attester_sets;
+pub mod errors;
+pub mod inclusion_distance;
+pub mod tests;
+pub mod winning_root;
+
+pub fn per_epoch_processing(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
+    let current_epoch = state.current_epoch(spec);
+    let previous_epoch = state.previous_epoch(spec);
+    let next_epoch = state.next_epoch(spec);
+
+    debug!(
+        "Starting per-epoch processing on epoch {}...",
+        state.current_epoch(spec)
+    );
+
+    // Ensure all of the caches are built.
+    state.build_epoch_cache(RelativeEpoch::Previous, spec)?;
+    state.build_epoch_cache(RelativeEpoch::Current, spec)?;
+    state.build_epoch_cache(RelativeEpoch::Next, spec)?;
+
+    let attesters = AttesterSets::new(&state, spec)?;
+
+    let active_validator_indices = get_active_validator_indices(
+        &state.validator_registry,
+        state.slot.epoch(spec.slots_per_epoch),
+    );
+
+    let current_total_balance = state.get_total_balance(&active_validator_indices[..], spec);
+    let previous_total_balance = state.get_total_balance(
+        &get_active_validator_indices(&state.validator_registry, previous_epoch)[..],
+        spec,
+    );
+
+    process_eth1_data(state, spec);
+
+    process_justification(
+        state,
+        current_total_balance,
+        previous_total_balance,
+        attesters.previous_epoch_boundary.balance,
+        attesters.current_epoch_boundary.balance,
+        spec,
+    );
+
+    // Crosslinks
+    let winning_root_for_shards = process_crosslinks(state, spec)?;
+
+    // Rewards and Penalities
+    let active_validator_indices_hashset: HashSet<usize> =
+        HashSet::from_iter(active_validator_indices.iter().cloned());
+    process_rewards_and_penalities(
+        state,
+        active_validator_indices_hashset,
+        &attesters,
+        previous_total_balance,
+        &winning_root_for_shards,
+        spec,
+    )?;
+
+    // Ejections
+    state.process_ejections(spec);
+
+    // Validator Registry
+    process_validator_registry(state, spec)?;
+
+    // Final updates
+    let active_tree_root = get_active_validator_indices(
+        &state.validator_registry,
+        next_epoch + Epoch::from(spec.activation_exit_delay),
+    )
+    .hash_tree_root();
+    state.latest_active_index_roots[(next_epoch.as_usize()
+        + spec.activation_exit_delay as usize)
+        % spec.latest_active_index_roots_length] = Hash256::from_slice(&active_tree_root[..]);
+
+    state.latest_slashed_balances[next_epoch.as_usize() % spec.latest_slashed_exit_length] =
+        state.latest_slashed_balances[current_epoch.as_usize() % spec.latest_slashed_exit_length];
+    state.latest_randao_mixes[next_epoch.as_usize() % spec.latest_randao_mixes_length] = state
+        .get_randao_mix(current_epoch, spec)
+        .and_then(|x| Some(*x))
+        .ok_or_else(|| Error::NoRandaoSeed)?;
+    state.latest_attestations = state
+        .latest_attestations
+        .iter()
+        .filter(|a| a.data.slot.epoch(spec.slots_per_epoch) >= current_epoch)
+        .cloned()
+        .collect();
+
+    // Rotate the epoch caches to suit the epoch transition.
+    state.advance_caches();
+
+    debug!("Epoch transition complete.");
+
+    Ok(())
+}
+
+/// Spec v0.4.0
+fn process_eth1_data(state: &mut BeaconState, spec: &ChainSpec) {
+    let next_epoch = state.next_epoch(spec);
+    let voting_period = spec.epochs_per_eth1_voting_period;
+
+    if next_epoch % voting_period == 0 {
+        for eth1_data_vote in &state.eth1_data_votes {
+            if eth1_data_vote.vote_count * 2 > voting_period {
+                state.latest_eth1_data = eth1_data_vote.eth1_data.clone();
+            }
+        }
+        state.eth1_data_votes = vec![];
+    }
+}
+
+/// Spec v0.4.0
+fn process_justification(
+    state: &mut BeaconState,
+    current_total_balance: u64,
+    previous_total_balance: u64,
+    previous_epoch_boundary_attesting_balance: u64,
+    current_epoch_boundary_attesting_balance: u64,
+    spec: &ChainSpec,
+) {
+    let previous_epoch = state.previous_epoch(spec);
+    let current_epoch = state.current_epoch(spec);
+
+    let mut new_justified_epoch = state.justified_epoch;
+    state.justification_bitfield <<= 1;
+
+    // If > 2/3 of the total balance attested to the previous epoch boundary
+    //
+    // - Set the 2nd bit of the bitfield.
+    // - Set the previous epoch to be justified.
+    if (3 * previous_epoch_boundary_attesting_balance) >= (2 * previous_total_balance) {
+        state.justification_bitfield |= 2;
+        new_justified_epoch = previous_epoch;
+    }
+    // If > 2/3 of the total balance attested to the previous epoch boundary
+    //
+    // - Set the 1st bit of the bitfield.
+    // - Set the current epoch to be justified.
+    if (3 * current_epoch_boundary_attesting_balance) >= (2 * current_total_balance) {
+        state.justification_bitfield |= 1;
+        new_justified_epoch = current_epoch;
+    }
+
+    // If:
+    //
+    // - All three epochs prior to this epoch have been justified.
+    // - The previous justified justified epoch was three epochs ago.
+    //
+    // Then, set the finalized epoch to be three epochs ago.
+    if ((state.justification_bitfield >> 1) % 8 == 0b111)
+        & (state.previous_justified_epoch == previous_epoch - 2)
+    {
+        state.finalized_epoch = state.previous_justified_epoch;
+    }
+    // If:
+    //
+    // - Both two epochs prior to this epoch have been justified.
+    // - The previous justified epoch was two epochs ago.
+    //
+    // Then, set the finalized epoch to two epochs ago.
+    if ((state.justification_bitfield >> 1) % 4 == 0b11)
+        & (state.previous_justified_epoch == previous_epoch - 1)
+    {
+        state.finalized_epoch = state.previous_justified_epoch;
+    }
+    // If:
+    //
+    // - This epoch and the two prior have been justified.
+    // - The presently justified epoch was two epochs ago.
+    //
+    // Then, set the finalized epoch to two epochs ago.
+    if (state.justification_bitfield % 8 == 0b111) & (state.justified_epoch == previous_epoch - 1) {
+        state.finalized_epoch = state.justified_epoch;
+    }
+    // If:
+    //
+    // - This epoch and the epoch prior to it have been justified.
+    // - Set the previous epoch to be justified.
+    //
+    // Then, set the finalized epoch to be the previous epoch.
+    if (state.justification_bitfield % 4 == 0b11) & (state.justified_epoch == previous_epoch) {
+        state.finalized_epoch = state.justified_epoch;
+    }
+
+    state.previous_justified_epoch = state.justified_epoch;
+    state.justified_epoch = new_justified_epoch;
+}
+
+pub type WinningRootHashSet = HashMap<u64, WinningRoot>;
+
+fn process_crosslinks(
+    state: &mut BeaconState,
+    spec: &ChainSpec,
+) -> Result<WinningRootHashSet, Error> {
+    let current_epoch_attestations: Vec<&PendingAttestation> = state
+        .latest_attestations
+        .par_iter()
+        .filter(|a| a.data.slot.epoch(spec.slots_per_epoch) == state.current_epoch(spec))
+        .collect();
+
+    let previous_epoch_attestations: Vec<&PendingAttestation> = state
+        .latest_attestations
+        .par_iter()
+        .filter(|a| a.data.slot.epoch(spec.slots_per_epoch) == state.previous_epoch(spec))
+        .collect();
+
+    let mut winning_root_for_shards: WinningRootHashSet = HashMap::new();
+
+    let previous_and_current_epoch_slots: Vec<Slot> = state
+        .previous_epoch(spec)
+        .slot_iter(spec.slots_per_epoch)
+        .chain(state.current_epoch(spec).slot_iter(spec.slots_per_epoch))
+        .collect();
+
+    for slot in previous_and_current_epoch_slots {
+        // Clone removes the borrow which becomes an issue when mutating `state.balances`.
+        let crosslink_committees_at_slot =
+            state.get_crosslink_committees_at_slot(slot, spec)?.clone();
+
+        for (crosslink_committee, shard) in crosslink_committees_at_slot {
+            let shard = shard as u64;
+
+            let winning_root = winning_root(
+                state,
+                shard,
+                &current_epoch_attestations[..],
+                &previous_epoch_attestations[..],
+                spec,
+            )?;
+
+            if let Some(winning_root) = winning_root {
+                let total_committee_balance = state.get_total_balance(&crosslink_committee, spec);
+
+                // TODO: I think this has a bug.
+                if (3 * winning_root.total_attesting_balance) >= (2 * total_committee_balance) {
+                    state.latest_crosslinks[shard as usize] = Crosslink {
+                        epoch: state.current_epoch(spec),
+                        crosslink_data_root: winning_root.crosslink_data_root,
+                    }
+                }
+                winning_root_for_shards.insert(shard, winning_root);
+            }
+        }
+    }
+
+    Ok(winning_root_for_shards)
+}
+
+/// Spec v0.4.0
+fn process_rewards_and_penalities(
+    state: &mut BeaconState,
+    active_validator_indices: HashSet<usize>,
+    attesters: &AttesterSets,
+    previous_total_balance: u64,
+    winning_root_for_shards: &WinningRootHashSet,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let next_epoch = state.next_epoch(spec);
+
+    let previous_epoch_attestations: Vec<&PendingAttestation> = state
+        .latest_attestations
+        .par_iter()
+        .filter(|a| a.data.slot.epoch(spec.slots_per_epoch) == state.previous_epoch(spec))
+        .collect();
+
+    let base_reward_quotient = previous_total_balance.integer_sqrt() / spec.base_reward_quotient;
+
+    if base_reward_quotient == 0 {
+        return Err(Error::BaseRewardQuotientIsZero);
+    }
+
+    // Justification and finalization
+
+    let epochs_since_finality = next_epoch - state.finalized_epoch;
+
+    if epochs_since_finality <= 4 {
+        for index in 0..state.validator_balances.len() {
+            let base_reward = state.base_reward(index, base_reward_quotient, spec);
+
+            // Expected FFG source
+            if attesters.previous_epoch.indices.contains(&index) {
+                safe_add_assign!(
+                    state.validator_balances[index],
+                    base_reward * attesters.previous_epoch.balance / previous_total_balance
+                );
+            } else if active_validator_indices.contains(&index) {
+                safe_sub_assign!(state.validator_balances[index], base_reward);
+            }
+
+            // Expected FFG target
+            if attesters.previous_epoch_boundary.indices.contains(&index) {
+                safe_add_assign!(
+                    state.validator_balances[index],
+                    base_reward * attesters.previous_epoch_boundary.balance
+                        / previous_total_balance
+                );
+            } else if active_validator_indices.contains(&index) {
+                safe_sub_assign!(state.validator_balances[index], base_reward);
+            }
+
+            // Expected beacon chain head
+            if attesters.previous_epoch_head.indices.contains(&index) {
+                safe_add_assign!(
+                    state.validator_balances[index],
+                    base_reward * attesters.previous_epoch_head.balance / previous_total_balance
+                );
+            } else if active_validator_indices.contains(&index) {
+                safe_sub_assign!(state.validator_balances[index], base_reward);
+            }
+        }
+
+        // Inclusion distance
+        for &index in &attesters.previous_epoch.indices {
+            let base_reward = state.base_reward(index, base_reward_quotient, spec);
+            let inclusion_distance =
+                inclusion_distance(state, &previous_epoch_attestations, index, spec)?;
+
+            safe_add_assign!(
+                state.validator_balances[index],
+                base_reward * spec.min_attestation_inclusion_delay / inclusion_distance
+            )
+        }
+    } else {
+        for index in 0..state.validator_balances.len() {
+            let inactivity_penalty =
+                state.inactivity_penalty(index, epochs_since_finality, base_reward_quotient, spec);
+
+            if active_validator_indices.contains(&index) {
+                if !attesters.previous_epoch.indices.contains(&index) {
+                    safe_sub_assign!(state.validator_balances[index], inactivity_penalty);
+                }
+                if !attesters.previous_epoch_boundary.indices.contains(&index) {
+                    safe_sub_assign!(state.validator_balances[index], inactivity_penalty);
+                }
+                if !attesters.previous_epoch_head.indices.contains(&index) {
+                    safe_sub_assign!(state.validator_balances[index], inactivity_penalty);
+                }
+
+                if state.validator_registry[index].slashed {
+                    let base_reward = state.base_reward(index, base_reward_quotient, spec);
+                    safe_sub_assign!(
+                        state.validator_balances[index],
+                        2 * inactivity_penalty + base_reward
+                    );
+                }
+            }
+        }
+
+        for &index in &attesters.previous_epoch.indices {
+            let base_reward = state.base_reward(index, base_reward_quotient, spec);
+            let inclusion_distance =
+                inclusion_distance(state, &previous_epoch_attestations, index, spec)?;
+
+            safe_sub_assign!(
+                state.validator_balances[index],
+                base_reward
+                    - base_reward * spec.min_attestation_inclusion_delay / inclusion_distance
+            );
+        }
+    }
+
+    // Attestation inclusion
+
+    for &index in &attesters.previous_epoch.indices {
+        let inclusion_slot = inclusion_slot(state, &previous_epoch_attestations[..], index, spec)?;
+
+        let proposer_index = state
+            .get_beacon_proposer_index(inclusion_slot, spec)
+            .map_err(|_| Error::UnableToDetermineProducer)?;
+
+        let base_reward = state.base_reward(proposer_index, base_reward_quotient, spec);
+
+        safe_add_assign!(
+            state.validator_balances[proposer_index],
+            base_reward / spec.attestation_inclusion_reward_quotient
+        );
+    }
+
+    //Crosslinks
+
+    for slot in state.previous_epoch(spec).slot_iter(spec.slots_per_epoch) {
+        // Clone removes the borrow which becomes an issue when mutating `state.balances`.
+        let crosslink_committees_at_slot =
+            state.get_crosslink_committees_at_slot(slot, spec)?.clone();
+
+        for (crosslink_committee, shard) in crosslink_committees_at_slot {
+            let shard = shard as u64;
+
+            // Note: I'm a little uncertain of the logic here -- I am waiting for spec v0.5.0 to
+            // clear it up.
+            //
+            // What happens here is:
+            //
+            // - If there was some crosslink root elected by the super-majority of this committee,
+            // then we reward all who voted for that root and penalize all that did not.
+            // - However, if there _was not_ some super-majority-voted crosslink root, then penalize
+            // all the validators.
+            //
+            // I'm not quite sure that the second case (no super-majority crosslink) is correct.
+            if let Some(winning_root) = winning_root_for_shards.get(&shard) {
+                // Hash set de-dedups and (hopefully) offers a speed improvement from faster
+                // lookups.
+                let attesting_validator_indices: HashSet<usize> =
+                    HashSet::from_iter(winning_root.attesting_validator_indices.iter().cloned());
+
+                for &index in &crosslink_committee {
+                    let base_reward = state.base_reward(index, base_reward_quotient, spec);
+
+                    let total_balance = state.get_total_balance(&crosslink_committee, spec);
+
+                    if attesting_validator_indices.contains(&index) {
+                        safe_add_assign!(
+                            state.validator_balances[index],
+                            base_reward * winning_root.total_attesting_balance / total_balance
+                        );
+                    } else {
+                        safe_sub_assign!(state.validator_balances[index], base_reward);
+                    }
+                }
+            } else {
+                for &index in &crosslink_committee {
+                    let base_reward = state.base_reward(index, base_reward_quotient, spec);
+
+                    safe_sub_assign!(state.validator_balances[index], base_reward);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+// Spec v0.4.0
+fn process_validator_registry(state: &mut BeaconState, spec: &ChainSpec) -> Result<(), Error> {
+    let current_epoch = state.current_epoch(spec);
+    let next_epoch = state.next_epoch(spec);
+
+    state.previous_shuffling_epoch = state.current_shuffling_epoch;
+    state.previous_shuffling_start_shard = state.current_shuffling_start_shard;
+
+    state.previous_shuffling_seed = state.current_shuffling_seed;
+
+    let should_update_validator_registy = if state.finalized_epoch
+        > state.validator_registry_update_epoch
+    {
+        (0..state.get_current_epoch_committee_count(spec)).all(|i| {
+            let shard = (state.current_shuffling_start_shard + i as u64) % spec.shard_count;
+            state.latest_crosslinks[shard as usize].epoch > state.validator_registry_update_epoch
+        })
+    } else {
+        false
+    };
+
+    if should_update_validator_registy {
+        state.update_validator_registry(spec);
+
+        state.current_shuffling_epoch = next_epoch;
+        state.current_shuffling_start_shard = (state.current_shuffling_start_shard
+            + state.get_current_epoch_committee_count(spec) as u64)
+            % spec.shard_count;
+        state.current_shuffling_seed = state.generate_seed(state.current_shuffling_epoch, spec)?
+    } else {
+        let epochs_since_last_registry_update =
+            current_epoch - state.validator_registry_update_epoch;
+        if (epochs_since_last_registry_update > 1)
+            & epochs_since_last_registry_update.is_power_of_two()
+        {
+            state.current_shuffling_epoch = next_epoch;
+            state.current_shuffling_seed =
+                state.generate_seed(state.current_shuffling_epoch, spec)?
+        }
+    }
+
+    state.process_slashings(spec);
+    state.process_exit_queue(spec);
+
+    Ok(())
+}

eth2/state_processing/src/per_epoch_processing/attester_sets.rs

@@ -0,0 +1,98 @@
+use std::collections::HashSet;
+use types::*;
+
+#[derive(Default)]
+pub struct Attesters {
+    pub indices: HashSet<usize>,
+    pub balance: u64,
+}
+
+impl Attesters {
+    fn add(&mut self, additional_indices: &[usize], additional_balance: u64) {
+        self.indices.reserve(additional_indices.len());
+        for i in additional_indices {
+            self.indices.insert(*i);
+        }
+        self.balance.saturating_add(additional_balance);
+    }
+}
+
+pub struct AttesterSets {
+    pub current_epoch: Attesters,
+    pub current_epoch_boundary: Attesters,
+    pub previous_epoch: Attesters,
+    pub previous_epoch_boundary: Attesters,
+    pub previous_epoch_head: Attesters,
+}
+
+impl AttesterSets {
+    pub fn new(state: &BeaconState, spec: &ChainSpec) -> Result<Self, BeaconStateError> {
+        let mut current_epoch = Attesters::default();
+        let mut current_epoch_boundary = Attesters::default();
+        let mut previous_epoch = Attesters::default();
+        let mut previous_epoch_boundary = Attesters::default();
+        let mut previous_epoch_head = Attesters::default();
+
+        for a in &state.latest_attestations {
+            let attesting_indices =
+                state.get_attestation_participants(&a.data, &a.aggregation_bitfield, spec)?;
+            let attesting_balance = state.get_total_balance(&attesting_indices, spec);
+
+            if is_from_epoch(a, state.current_epoch(spec), spec) {
+                current_epoch.add(&attesting_indices, attesting_balance);
+
+                if has_common_epoch_boundary_root(a, state, state.current_epoch(spec), spec)? {
+                    current_epoch_boundary.add(&attesting_indices, attesting_balance);
+                }
+            } else if is_from_epoch(a, state.previous_epoch(spec), spec) {
+                previous_epoch.add(&attesting_indices, attesting_balance);
+
+                if has_common_epoch_boundary_root(a, state, state.previous_epoch(spec), spec)? {
+                    previous_epoch_boundary.add(&attesting_indices, attesting_balance);
+                }
+
+                if has_common_beacon_block_root(a, state, spec)? {
+                    previous_epoch_head.add(&attesting_indices, attesting_balance);
+                }
+            }
+        }
+
+        Ok(Self {
+            current_epoch,
+            current_epoch_boundary,
+            previous_epoch,
+            previous_epoch_boundary,
+            previous_epoch_head,
+        })
+    }
+}
+
+fn is_from_epoch(a: &PendingAttestation, epoch: Epoch, spec: &ChainSpec) -> bool {
+    a.data.slot.epoch(spec.slots_per_epoch) == epoch
+}
+
+fn has_common_epoch_boundary_root(
+    a: &PendingAttestation,
+    state: &BeaconState,
+    epoch: Epoch,
+    spec: &ChainSpec,
+) -> Result<bool, BeaconStateError> {
+    let slot = epoch.start_slot(spec.slots_per_epoch);
+    let state_boundary_root = *state
+        .get_block_root(slot, spec)
+        .ok_or_else(|| BeaconStateError::InsufficientBlockRoots)?;
+
+    Ok(a.data.epoch_boundary_root == state_boundary_root)
+}
+
+fn has_common_beacon_block_root(
+    a: &PendingAttestation,
+    state: &BeaconState,
+    spec: &ChainSpec,
+) -> Result<bool, BeaconStateError> {
+    let state_block_root = *state
+        .get_block_root(a.data.slot, spec)
+        .ok_or_else(|| BeaconStateError::InsufficientBlockRoots)?;
+
+    Ok(a.data.beacon_block_root == state_block_root)
+}

eth2/state_processing/src/per_epoch_processing/errors.rs

@@ -0,0 +1,36 @@
+use types::*;
+
+#[derive(Debug, PartialEq)]
+pub enum EpochProcessingError {
+    UnableToDetermineProducer,
+    NoBlockRoots,
+    BaseRewardQuotientIsZero,
+    NoRandaoSeed,
+    BeaconStateError(BeaconStateError),
+    InclusionError(InclusionError),
+}
+
+impl From<InclusionError> for EpochProcessingError {
+    fn from(e: InclusionError) -> EpochProcessingError {
+        EpochProcessingError::InclusionError(e)
+    }
+}
+
+impl From<BeaconStateError> for EpochProcessingError {
+    fn from(e: BeaconStateError) -> EpochProcessingError {
+        EpochProcessingError::BeaconStateError(e)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum InclusionError {
+    /// The validator did not participate in an attestation in this period.
+    NoAttestationsForValidator,
+    BeaconStateError(BeaconStateError),
+}
+
+impl From<BeaconStateError> for InclusionError {
+    fn from(e: BeaconStateError) -> InclusionError {
+        InclusionError::BeaconStateError(e)
+    }
+}

eth2/state_processing/src/per_epoch_processing/inclusion_distance.rs

@@ -0,0 +1,61 @@
+use super::errors::InclusionError;
+use types::*;
+
+/// Returns the distance between the first included attestation for some validator and this
+/// slot.
+///
+/// Note: In the spec this is defined "inline", not as a helper function.
+///
+/// Spec v0.4.0
+pub fn inclusion_distance(
+    state: &BeaconState,
+    attestations: &[&PendingAttestation],
+    validator_index: usize,
+    spec: &ChainSpec,
+) -> Result<u64, InclusionError> {
+    let attestation = earliest_included_attestation(state, attestations, validator_index, spec)?;
+    Ok((attestation.inclusion_slot - attestation.data.slot).as_u64())
+}
+
+/// Returns the slot of the earliest included attestation for some validator.
+///
+/// Note: In the spec this is defined "inline", not as a helper function.
+///
+/// Spec v0.4.0
+pub fn inclusion_slot(
+    state: &BeaconState,
+    attestations: &[&PendingAttestation],
+    validator_index: usize,
+    spec: &ChainSpec,
+) -> Result<Slot, InclusionError> {
+    let attestation = earliest_included_attestation(state, attestations, validator_index, spec)?;
+    Ok(attestation.inclusion_slot)
+}
+
+/// Finds the earliest included attestation for some validator.
+///
+/// Note: In the spec this is defined "inline", not as a helper function.
+///
+/// Spec v0.4.0
+fn earliest_included_attestation(
+    state: &BeaconState,
+    attestations: &[&PendingAttestation],
+    validator_index: usize,
+    spec: &ChainSpec,
+) -> Result<PendingAttestation, InclusionError> {
+    let mut included_attestations = vec![];
+
+    for (i, a) in attestations.iter().enumerate() {
+        let participants =
+            state.get_attestation_participants(&a.data, &a.aggregation_bitfield, spec)?;
+        if participants.iter().any(|i| *i == validator_index) {
+            included_attestations.push(i);
+        }
+    }
+
+    let earliest_attestation_index = included_attestations
+        .iter()
+        .min_by_key(|i| attestations[**i].inclusion_slot)
+        .ok_or_else(|| InclusionError::NoAttestationsForValidator)?;
+    Ok(attestations[*earliest_attestation_index].clone())
+}

eth2/state_processing/src/per_epoch_processing/tests.rs

@@ -0,0 +1,21 @@
+#![cfg(test)]
+use crate::per_epoch_processing;
+use env_logger::{Builder, Env};
+use types::beacon_state::BeaconStateBuilder;
+use types::*;
+
+#[test]
+fn runs_without_error() {
+    Builder::from_env(Env::default().default_filter_or("error")).init();
+
+    let mut builder = BeaconStateBuilder::new(8);
+    builder.spec = ChainSpec::few_validators();
+
+    builder.build().unwrap();
+    builder.teleport_to_end_of_epoch(builder.spec.genesis_epoch + 4);
+
+    let mut state = builder.cloned_state();
+
+    let spec = &builder.spec;
+    per_epoch_processing(&mut state, spec).unwrap();
+}

eth2/state_processing/src/per_epoch_processing/winning_root.rs

@@ -0,0 +1,118 @@
+use std::collections::HashSet;
+use std::iter::FromIterator;
+use types::*;
+
+#[derive(Clone)]
+pub struct WinningRoot {
+    pub crosslink_data_root: Hash256,
+    pub attesting_validator_indices: Vec<usize>,
+    pub total_attesting_balance: u64,
+}
+
+impl WinningRoot {
+    /// Returns `true` if `self` is a "better" candidate than `other`.
+    ///
+    /// A winning root is "better" than another if it has a higher `total_attesting_balance`. Ties
+    /// are broken by favouring the lower `crosslink_data_root` value.
+    ///
+    /// Spec v0.4.0
+    pub fn is_better_than(&self, other: &Self) -> bool {
+        if self.total_attesting_balance > other.total_attesting_balance {
+            true
+        } else if self.total_attesting_balance == other.total_attesting_balance {
+            self.crosslink_data_root < other.crosslink_data_root
+        } else {
+            false
+        }
+    }
+}
+
+/// Returns the `crosslink_data_root` with the highest total attesting balance for the given shard.
+/// Breaks ties by favouring the smaller `crosslink_data_root` hash.
+///
+/// The `WinningRoot` object also contains additional fields that are useful in later stages of
+/// per-epoch processing.
+///
+/// Spec v0.4.0
+pub fn winning_root(
+    state: &BeaconState,
+    shard: u64,
+    current_epoch_attestations: &[&PendingAttestation],
+    previous_epoch_attestations: &[&PendingAttestation],
+    spec: &ChainSpec,
+) -> Result<Option<WinningRoot>, BeaconStateError> {
+    let mut winning_root: Option<WinningRoot> = None;
+
+    let crosslink_data_roots: HashSet<Hash256> = HashSet::from_iter(
+        previous_epoch_attestations
+            .iter()
+            .chain(current_epoch_attestations.iter())
+            .filter_map(|a| {
+                if a.data.shard == shard {
+                    Some(a.data.crosslink_data_root)
+                } else {
+                    None
+                }
+            }),
+    );
+
+    for crosslink_data_root in crosslink_data_roots {
+        let attesting_validator_indices = get_attesting_validator_indices(
+            state,
+            shard,
+            current_epoch_attestations,
+            previous_epoch_attestations,
+            &crosslink_data_root,
+            spec,
+        )?;
+
+        let total_attesting_balance: u64 = attesting_validator_indices
+            .iter()
+            .fold(0, |acc, i| acc + state.get_effective_balance(*i, spec));
+
+        let candidate = WinningRoot {
+            crosslink_data_root,
+            attesting_validator_indices,
+            total_attesting_balance,
+        };
+
+        if let Some(ref winner) = winning_root {
+            if candidate.is_better_than(&winner) {
+                winning_root = Some(candidate);
+            }
+        } else {
+            winning_root = Some(candidate);
+        }
+    }
+
+    Ok(winning_root)
+}
+
+/// Returns all indices which voted for a given crosslink. May contain duplicates.
+///
+/// Spec v0.4.0
+fn get_attesting_validator_indices(
+    state: &BeaconState,
+    shard: u64,
+    current_epoch_attestations: &[&PendingAttestation],
+    previous_epoch_attestations: &[&PendingAttestation],
+    crosslink_data_root: &Hash256,
+    spec: &ChainSpec,
+) -> Result<Vec<usize>, BeaconStateError> {
+    let mut indices = vec![];
+
+    for a in current_epoch_attestations
+        .iter()
+        .chain(previous_epoch_attestations.iter())
+    {
+        if (a.data.shard == shard) && (a.data.crosslink_data_root == *crosslink_data_root) {
+            indices.append(&mut state.get_attestation_participants(
+                &a.data,
+                &a.aggregation_bitfield,
+                spec,
+            )?);
+        }
+    }
+
+    Ok(indices)
+}

eth2/state_processing/src/per_slot_processing.rs

@@ -0,0 +1,58 @@
+use crate::*;
+use types::{BeaconState, BeaconStateError, ChainSpec, Hash256};
+
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    BeaconStateError(BeaconStateError),
+    EpochProcessingError(EpochProcessingError),
+}
+
+/// Advances a state forward by one slot, performing per-epoch processing if required.
+///
+/// Spec v0.4.0
+pub fn per_slot_processing(
+    state: &mut BeaconState,
+    previous_block_root: Hash256,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    if (state.slot + 1) % spec.slots_per_epoch == 0 {
+        per_epoch_processing(state, spec)?;
+        state.advance_caches();
+    }
+
+    state.slot += 1;
+
+    update_block_roots(state, previous_block_root, spec);
+
+    Ok(())
+}
+
+/// Updates the state's block roots as per-slot processing is performed.
+///
+/// Spec v0.4.0
+pub fn update_block_roots(state: &mut BeaconState, previous_block_root: Hash256, spec: &ChainSpec) {
+    state.latest_block_roots[(state.slot.as_usize() - 1) % spec.latest_block_roots_length] =
+        previous_block_root;
+
+    if state.slot.as_usize() % spec.latest_block_roots_length == 0 {
+        let root = merkle_root(&state.latest_block_roots[..]);
+        state.batched_block_roots.push(root);
+    }
+}
+
+fn merkle_root(_input: &[Hash256]) -> Hash256 {
+    // TODO: implement correctly.
+    Hash256::zero()
+}
+
+impl From<BeaconStateError> for Error {
+    fn from(e: BeaconStateError) -> Error {
+        Error::BeaconStateError(e)
+    }
+}
+
+impl From<EpochProcessingError> for Error {
+    fn from(e: EpochProcessingError) -> Error {
+        Error::EpochProcessingError(e)
+    }
+}

eth2/state_processing/src/slot_processable.rs

@@ -1,70 +0,0 @@
-use crate::{EpochProcessable, EpochProcessingError};
-use types::{BeaconState, BeaconStateError, ChainSpec, Hash256};
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    BeaconStateError(BeaconStateError),
-    EpochProcessingError(EpochProcessingError),
-}
-
-pub trait SlotProcessable {
-    fn per_slot_processing(
-        &mut self,
-        previous_block_root: Hash256,
-        spec: &ChainSpec,
-    ) -> Result<(), Error>;
-}
-
-impl SlotProcessable for BeaconState
-where
-    BeaconState: EpochProcessable,
-{
-    fn per_slot_processing(
-        &mut self,
-        previous_block_root: Hash256,
-        spec: &ChainSpec,
-    ) -> Result<(), Error> {
-        if (self.slot + 1) % spec.epoch_length == 0 {
-            self.per_epoch_processing(spec)?;
-        }
-
-        self.slot += 1;
-
-        self.latest_randao_mixes[self.slot.as_usize() % spec.latest_randao_mixes_length] =
-            self.latest_randao_mixes[(self.slot.as_usize() - 1) % spec.latest_randao_mixes_length];
-
-        // Block roots.
-        self.latest_block_roots[(self.slot.as_usize() - 1) % spec.latest_block_roots_length] =
-            previous_block_root;
-
-        if self.slot.as_usize() % spec.latest_block_roots_length == 0 {
-            let root = merkle_root(&self.latest_block_roots[..]);
-            self.batched_block_roots.push(root);
-        }
-        Ok(())
-    }
-}
-
-fn merkle_root(_input: &[Hash256]) -> Hash256 {
-    Hash256::zero()
-}
-
-impl From<BeaconStateError> for Error {
-    fn from(e: BeaconStateError) -> Error {
-        Error::BeaconStateError(e)
-    }
-}
-
-impl From<EpochProcessingError> for Error {
-    fn from(e: EpochProcessingError) -> Error {
-        Error::EpochProcessingError(e)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}

eth2/types/Cargo.toml

@@ -7,9 +7,10 @@ edition = "2018"
 [dependencies]
 bls = { path = "../utils/bls" }
 boolean-bitfield = { path = "../utils/boolean-bitfield" }
-ethereum-types = "0.4.0"
+ethereum-types = "0.5"
 hashing = { path = "../utils/hashing" }
 honey-badger-split =  { path = "../utils/honey-badger-split" }
+int_to_bytes = { path = "../utils/int_to_bytes" }
 log = "0.4"
 rayon = "1.0"
 rand = "0.5.5"

eth2/types/src/attestation.rs

@@ -1,12 +1,15 @@
-use super::{AggregatePublicKey, AggregateSignature, AttestationData, Bitfield, Hash256};
+use super::{AggregateSignature, AttestationData, Bitfield};
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
 use ssz::TreeHash;
-use ssz_derive::{Decode, Encode, TreeHash};
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode, TreeHash, TestRandom)]
+/// Details an attestation that can be slashable.
+///
+/// Spec v0.4.0
+#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
 pub struct Attestation {
     pub aggregation_bitfield: Bitfield,
     pub data: AttestationData,
@@ -14,29 +17,6 @@ pub struct Attestation {
     pub aggregate_signature: AggregateSignature,
 }
 
-impl Attestation {
-    pub fn canonical_root(&self) -> Hash256 {
-        Hash256::from(&self.hash_tree_root()[..])
-    }
-
-    pub fn signable_message(&self, custody_bit: bool) -> Vec<u8> {
-        self.data.signable_message(custody_bit)
-    }
-
-    pub fn verify_signature(
-        &self,
-        group_public_key: &AggregatePublicKey,
-        custody_bit: bool,
-        domain: u64,
-    ) -> bool {
-        self.aggregate_signature.verify(
-            &self.signable_message(custody_bit),
-            domain,
-            group_public_key,
-        )
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

eth2/types/src/attestation_data.rs

@@ -1,31 +1,33 @@
 use crate::test_utils::TestRandom;
-use crate::{AttestationDataAndCustodyBit, Crosslink, Epoch, Hash256, Slot};
+use crate::{Crosslink, Epoch, Hash256, Slot};
 use rand::RngCore;
 use serde_derive::Serialize;
 use ssz::TreeHash;
-use ssz_derive::{Decode, Encode, TreeHash};
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
-pub const SSZ_ATTESTION_DATA_LENGTH: usize = {
-    8 +             // slot
-    8 +             // shard
-    32 +            // beacon_block_hash
-    32 +            // epoch_boundary_root
-    32 +            // shard_block_hash
-    32 +            // latest_crosslink_hash
-    8 +             // justified_epoch
-    32 // justified_block_root
-};
-
+/// The data upon which an attestation is based.
+///
+/// Spec v0.4.0
 #[derive(
-    Debug, Clone, PartialEq, Default, Serialize, Hash, Encode, Decode, TreeHash, TestRandom,
+    Debug,
+    Clone,
+    PartialEq,
+    Default,
+    Serialize,
+    Hash,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+    SignedRoot,
 )]
 pub struct AttestationData {
     pub slot: Slot,
     pub shard: u64,
     pub beacon_block_root: Hash256,
     pub epoch_boundary_root: Hash256,
-    pub shard_block_root: Hash256,
+    pub crosslink_data_root: Hash256,
     pub latest_crosslink: Crosslink,
     pub justified_epoch: Epoch,
     pub justified_block_root: Hash256,
@@ -33,20 +35,6 @@ pub struct AttestationData {
 
 impl Eq for AttestationData {}
 
-impl AttestationData {
-    pub fn canonical_root(&self) -> Hash256 {
-        Hash256::from(&self.hash_tree_root()[..])
-    }
-
-    pub fn signable_message(&self, custody_bit: bool) -> Vec<u8> {
-        let attestation_data_and_custody_bit = AttestationDataAndCustodyBit {
-            data: self.clone(),
-            custody_bit,
-        };
-        attestation_data_and_custody_bit.hash_tree_root()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

eth2/types/src/attestation_data_and_custody_bit.rs

@@ -4,6 +4,9 @@ use rand::RngCore;
 use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 
+/// Used for pairing an attestation with a proof-of-custody.
+///
+/// Spec v0.4.0
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Encode, Decode, TreeHash)]
 pub struct AttestationDataAndCustodyBit {
     pub data: AttestationData,
@@ -14,8 +17,7 @@ impl<T: RngCore> TestRandom<T> for AttestationDataAndCustodyBit {
     fn random_for_test(rng: &mut T) -> Self {
         Self {
             data: <_>::random_for_test(rng),
-            // TODO: deal with bools
-            custody_bit: false,
+            custody_bit: <_>::random_for_test(rng),
         }
     }
 }

eth2/types/src/attester_slashing.rs

@@ -4,6 +4,13 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+mod builder;
+
+pub use builder::AttesterSlashingBuilder;
+
+/// Two conflicting attestations.
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct AttesterSlashing {
     pub slashable_attestation_1: SlashableAttestation,

eth2/types/src/attester_slashing/builder.rs

@@ -0,0 +1,87 @@
+use crate::*;
+use ssz::TreeHash;
+
+/// Builds an `AttesterSlashing`.
+pub struct AttesterSlashingBuilder();
+
+impl AttesterSlashingBuilder {
+    /// Builds an `AttesterSlashing` that is a double vote.
+    ///
+    /// The `signer` function is used to sign the double-vote and accepts:
+    ///
+    /// - `validator_index: u64`
+    /// - `message: &[u8]`
+    /// - `epoch: Epoch`
+    /// - `domain: Domain`
+    ///
+    /// Where domain is a domain "constant" (e.g., `spec.domain_attestation`).
+    pub fn double_vote<F>(validator_indices: &[u64], signer: F) -> AttesterSlashing
+    where
+        F: Fn(u64, &[u8], Epoch, Domain) -> Signature,
+    {
+        let double_voted_slot = Slot::new(0);
+        let shard = 0;
+        let justified_epoch = Epoch::new(0);
+        let epoch = Epoch::new(0);
+        let hash_1 = Hash256::from_low_u64_le(1);
+        let hash_2 = Hash256::from_low_u64_le(2);
+
+        let mut slashable_attestation_1 = SlashableAttestation {
+            validator_indices: validator_indices.to_vec(),
+            data: AttestationData {
+                slot: double_voted_slot,
+                shard,
+                beacon_block_root: hash_1,
+                epoch_boundary_root: hash_1,
+                crosslink_data_root: hash_1,
+                latest_crosslink: Crosslink {
+                    epoch,
+                    crosslink_data_root: hash_1,
+                },
+                justified_epoch,
+                justified_block_root: hash_1,
+            },
+            custody_bitfield: Bitfield::new(),
+            aggregate_signature: AggregateSignature::new(),
+        };
+
+        let mut slashable_attestation_2 = SlashableAttestation {
+            validator_indices: validator_indices.to_vec(),
+            data: AttestationData {
+                slot: double_voted_slot,
+                shard,
+                beacon_block_root: hash_2,
+                epoch_boundary_root: hash_2,
+                crosslink_data_root: hash_2,
+                latest_crosslink: Crosslink {
+                    epoch,
+                    crosslink_data_root: hash_2,
+                },
+                justified_epoch,
+                justified_block_root: hash_2,
+            },
+            custody_bitfield: Bitfield::new(),
+            aggregate_signature: AggregateSignature::new(),
+        };
+
+        let add_signatures = |attestation: &mut SlashableAttestation| {
+            for (i, validator_index) in validator_indices.iter().enumerate() {
+                let attestation_data_and_custody_bit = AttestationDataAndCustodyBit {
+                    data: attestation.data.clone(),
+                    custody_bit: attestation.custody_bitfield.get(i).unwrap(),
+                };
+                let message = attestation_data_and_custody_bit.hash_tree_root();
+                let signature = signer(*validator_index, &message[..], epoch, Domain::Attestation);
+                attestation.aggregate_signature.add(&signature);
+            }
+        };
+
+        add_signatures(&mut slashable_attestation_1);
+        add_signatures(&mut slashable_attestation_2);
+
+        AttesterSlashing {
+            slashable_attestation_1,
+            slashable_attestation_2,
+        }
+    }
+}

eth2/types/src/beacon_block.rs

@@ -1,21 +1,24 @@
 use crate::test_utils::TestRandom;
-use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, ProposalSignedData, Slot};
+use crate::{BeaconBlockBody, ChainSpec, Eth1Data, Hash256, Slot};
 use bls::Signature;
 use rand::RngCore;
 use serde_derive::Serialize;
 use ssz::TreeHash;
-use ssz_derive::{Decode, Encode, TreeHash};
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
+/// A block of the `BeaconChain`.
+///
+/// Spec v0.4.0
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
 pub struct BeaconBlock {
     pub slot: Slot,
     pub parent_root: Hash256,
     pub state_root: Hash256,
     pub randao_reveal: Signature,
     pub eth1_data: Eth1Data,
-    pub signature: Signature,
     pub body: BeaconBlockBody,
+    pub signature: Signature,
 }
 
 impl BeaconBlock {
@@ -36,28 +39,15 @@ impl BeaconBlock {
                 attester_slashings: vec![],
                 attestations: vec![],
                 deposits: vec![],
-                exits: vec![],
+                voluntary_exits: vec![],
+                transfers: vec![],
             },
         }
     }
 
+    /// Returns the `hash_tree_root` of the block.
     pub fn canonical_root(&self) -> Hash256 {
-        Hash256::from(&self.hash_tree_root()[..])
-    }
-
-    pub fn proposal_root(&self, spec: &ChainSpec) -> Hash256 {
-        let block_without_signature_root = {
-            let mut block_without_signature = self.clone();
-            block_without_signature.signature = spec.empty_signature.clone();
-            block_without_signature.canonical_root()
-        };
-
-        let proposal = ProposalSignedData {
-            slot: self.slot,
-            shard: spec.beacon_chain_shard_number,
-            block_root: block_without_signature_root,
-        };
-        Hash256::from(&proposal.hash_tree_root()[..])
+        Hash256::from_slice(&self.hash_tree_root()[..])
     }
 }
 

eth2/types/src/beacon_block_body.rs

@@ -1,17 +1,21 @@
-use super::{Attestation, AttesterSlashing, Deposit, Exit, ProposerSlashing};
+use super::{Attestation, AttesterSlashing, Deposit, ProposerSlashing, Transfer, VoluntaryExit};
 use crate::test_utils::TestRandom;
 use rand::RngCore;
 use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+/// The body of a `BeaconChain` block, containing operations.
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct BeaconBlockBody {
     pub proposer_slashings: Vec<ProposerSlashing>,
     pub attester_slashings: Vec<AttesterSlashing>,
     pub attestations: Vec<Attestation>,
     pub deposits: Vec<Deposit>,
-    pub exits: Vec<Exit>,
+    pub voluntary_exits: Vec<VoluntaryExit>,
+    pub transfers: Vec<Transfer>,
 }
 
 #[cfg(test)]

eth2/types/src/beacon_state/builder.rs

@@ -0,0 +1,263 @@
+use crate::*;
+use bls::create_proof_of_possession;
+
+/// Builds a `BeaconState` for use in testing or benchmarking.
+///
+/// Building the `BeaconState` is a three step processes:
+///
+/// 1. Create a new `BeaconStateBuilder`.
+/// 2. Call `Self::build()` or `Self::build_fast()` generate a  `BeaconState`.
+/// 3. (Optional) Use builder functions to modify the `BeaconState`.
+/// 4. Call `Self::cloned_state()` to obtain a `BeaconState` cloned from this struct.
+///
+/// Step (2) happens prior to step (3) because some functionality requires an existing
+/// `BeaconState`.
+///
+/// Step (4) produces a clone of the BeaconState and doesn't consume the `BeaconStateBuilder` to
+/// allow access to `self.keypairs` and `self.spec`.
+pub struct BeaconStateBuilder {
+    pub validator_count: usize,
+    pub state: Option<BeaconState>,
+    pub genesis_time: u64,
+    pub latest_eth1_data: Eth1Data,
+    pub spec: ChainSpec,
+    pub keypairs: Vec<Keypair>,
+}
+
+impl BeaconStateBuilder {
+    /// Create a new builder with the given number of validators.
+    pub fn new(validator_count: usize) -> Self {
+        let genesis_time = 10_000_000;
+
+        let latest_eth1_data = Eth1Data {
+            deposit_root: Hash256::zero(),
+            block_hash: Hash256::zero(),
+        };
+
+        let spec = ChainSpec::foundation();
+
+        Self {
+            validator_count,
+            state: None,
+            genesis_time,
+            latest_eth1_data,
+            spec,
+            keypairs: vec![],
+        }
+    }
+
+    /// Builds a `BeaconState` using the `BeaconState::genesis(..)` function.
+    ///
+    /// Each validator is assigned a unique, randomly-generated keypair and all
+    /// proof-of-possessions are verified during genesis.
+    pub fn build(&mut self) -> Result<(), BeaconStateError> {
+        self.keypairs = (0..self.validator_count)
+            .collect::<Vec<usize>>()
+            .iter()
+            .map(|_| Keypair::random())
+            .collect();
+
+        let initial_validator_deposits = self
+            .keypairs
+            .iter()
+            .map(|keypair| Deposit {
+                branch: vec![], // branch verification is not specified.
+                index: 0,       // index verification is not specified.
+                deposit_data: DepositData {
+                    amount: 32_000_000_000, // 32 ETH (in Gwei)
+                    timestamp: self.genesis_time - 1,
+                    deposit_input: DepositInput {
+                        pubkey: keypair.pk.clone(),
+                        withdrawal_credentials: Hash256::zero(), // Withdrawal not possible.
+                        proof_of_possession: create_proof_of_possession(&keypair),
+                    },
+                },
+            })
+            .collect();
+
+        let state = BeaconState::genesis(
+            self.genesis_time,
+            initial_validator_deposits,
+            self.latest_eth1_data.clone(),
+            &self.spec,
+        )?;
+
+        self.state = Some(state);
+
+        Ok(())
+    }
+
+    /// Builds a `BeaconState` using the `BeaconState::genesis(..)` function, without supplying any
+    /// validators. Instead validators are added to the state post-genesis.
+    ///
+    /// One keypair is randomly generated and all validators are assigned this same keypair.
+    /// Proof-of-possessions are not created (or validated).
+    ///
+    /// This function runs orders of magnitude faster than `Self::build()`, however it will be
+    /// erroneous for functions which use a validators public key as an identifier (e.g.,
+    /// deposits).
+    pub fn build_fast(&mut self) -> Result<(), BeaconStateError> {
+        let common_keypair = Keypair::random();
+
+        let mut validator_registry = Vec::with_capacity(self.validator_count);
+        let mut validator_balances = Vec::with_capacity(self.validator_count);
+        self.keypairs = Vec::with_capacity(self.validator_count);
+
+        for _ in 0..self.validator_count {
+            self.keypairs.push(common_keypair.clone());
+            validator_balances.push(32_000_000_000);
+            validator_registry.push(Validator {
+                pubkey: common_keypair.pk.clone(),
+                withdrawal_credentials: Hash256::zero(),
+                activation_epoch: self.spec.genesis_epoch,
+                ..Validator::default()
+            })
+        }
+
+        let state = BeaconState {
+            validator_registry,
+            validator_balances,
+            ..BeaconState::genesis(
+                self.genesis_time,
+                vec![],
+                self.latest_eth1_data.clone(),
+                &self.spec,
+            )?
+        };
+
+        self.state = Some(state);
+
+        Ok(())
+    }
+
+    /// Sets the `BeaconState` to be in the last slot of the given epoch.
+    ///
+    /// Sets all justification/finalization parameters to be be as "perfect" as possible (i.e.,
+    /// highest justified and finalized slots, full justification bitfield, etc).
+    pub fn teleport_to_end_of_epoch(&mut self, epoch: Epoch) {
+        let state = self.state.as_mut().expect("Genesis required");
+
+        let slot = epoch.end_slot(self.spec.slots_per_epoch);
+
+        state.slot = slot;
+        state.validator_registry_update_epoch = epoch - 1;
+
+        state.previous_shuffling_epoch = epoch - 1;
+        state.current_shuffling_epoch = epoch;
+
+        state.previous_shuffling_seed = Hash256::from_low_u64_le(0);
+        state.current_shuffling_seed = Hash256::from_low_u64_le(1);
+
+        state.previous_justified_epoch = epoch - 2;
+        state.justified_epoch = epoch - 1;
+        state.justification_bitfield = u64::max_value();
+        state.finalized_epoch = epoch - 1;
+    }
+
+    /// Creates a full set of attestations for the `BeaconState`. Each attestation has full
+    /// participation from its committee and references the expected beacon_block hashes.
+    ///
+    /// These attestations should be fully conducive to justification and finalization.
+    pub fn insert_attestations(&mut self) {
+        let state = self.state.as_mut().expect("Genesis required");
+
+        state
+            .build_epoch_cache(RelativeEpoch::Previous, &self.spec)
+            .unwrap();
+        state
+            .build_epoch_cache(RelativeEpoch::Current, &self.spec)
+            .unwrap();
+
+        let current_epoch = state.current_epoch(&self.spec);
+        let previous_epoch = state.previous_epoch(&self.spec);
+        let current_epoch_depth =
+            (state.slot - current_epoch.end_slot(self.spec.slots_per_epoch)).as_usize();
+
+        let previous_epoch_slots = previous_epoch.slot_iter(self.spec.slots_per_epoch);
+        let current_epoch_slots = current_epoch
+            .slot_iter(self.spec.slots_per_epoch)
+            .take(current_epoch_depth);
+
+        for slot in previous_epoch_slots.chain(current_epoch_slots) {
+            let committees = state
+                .get_crosslink_committees_at_slot(slot, &self.spec)
+                .unwrap()
+                .clone();
+
+            for (committee, shard) in committees {
+                state
+                    .latest_attestations
+                    .push(committee_to_pending_attestation(
+                        state, &committee, shard, slot, &self.spec,
+                    ))
+            }
+        }
+    }
+
+    /// Returns a cloned `BeaconState`.
+    pub fn cloned_state(&self) -> BeaconState {
+        self.state.as_ref().expect("Genesis required").clone()
+    }
+}
+
+/// Builds a valid PendingAttestation with full participation for some committee.
+fn committee_to_pending_attestation(
+    state: &BeaconState,
+    committee: &[usize],
+    shard: u64,
+    slot: Slot,
+    spec: &ChainSpec,
+) -> PendingAttestation {
+    let current_epoch = state.current_epoch(spec);
+    let previous_epoch = state.previous_epoch(spec);
+
+    let mut aggregation_bitfield = Bitfield::new();
+    let mut custody_bitfield = Bitfield::new();
+
+    for (i, _) in committee.iter().enumerate() {
+        aggregation_bitfield.set(i, true);
+        custody_bitfield.set(i, true);
+    }
+
+    let is_previous_epoch =
+        state.slot.epoch(spec.slots_per_epoch) != slot.epoch(spec.slots_per_epoch);
+
+    let justified_epoch = if is_previous_epoch {
+        state.previous_justified_epoch
+    } else {
+        state.justified_epoch
+    };
+
+    let epoch_boundary_root = if is_previous_epoch {
+        *state
+            .get_block_root(previous_epoch.start_slot(spec.slots_per_epoch), spec)
+            .unwrap()
+    } else {
+        *state
+            .get_block_root(current_epoch.start_slot(spec.slots_per_epoch), spec)
+            .unwrap()
+    };
+
+    let justified_block_root = *state
+        .get_block_root(justified_epoch.start_slot(spec.slots_per_epoch), &spec)
+        .unwrap();
+
+    PendingAttestation {
+        aggregation_bitfield,
+        data: AttestationData {
+            slot,
+            shard,
+            beacon_block_root: *state.get_block_root(slot, spec).unwrap(),
+            epoch_boundary_root,
+            crosslink_data_root: Hash256::zero(),
+            latest_crosslink: Crosslink {
+                epoch: slot.epoch(spec.slots_per_epoch),
+                crosslink_data_root: Hash256::zero(),
+            },
+            justified_epoch,
+            justified_block_root,
+        },
+        custody_bitfield,
+        inclusion_slot: slot,
+    }
+}

eth2/types/src/beacon_state/epoch_cache.rs

@@ -32,14 +32,14 @@ impl EpochCache {
         spec: &ChainSpec,
     ) -> Result<EpochCache, Error> {
         let mut epoch_committees: Vec<CrosslinkCommittees> =
-            Vec::with_capacity(spec.epoch_length as usize);
+            Vec::with_capacity(spec.slots_per_epoch as usize);
         let mut attestation_duty_map: AttestationDutyMap = HashMap::new();
         let mut shard_committee_index_map: ShardCommitteeIndexMap = HashMap::new();
 
         let shuffling =
-            state.get_shuffling_for_slot(epoch.start_slot(spec.epoch_length), false, spec)?;
+            state.get_shuffling_for_slot(epoch.start_slot(spec.slots_per_epoch), false, spec)?;
 
-        for (epoch_committeess_index, slot) in epoch.slot_iter(spec.epoch_length).enumerate() {
+        for (epoch_committeess_index, slot) in epoch.slot_iter(spec.slots_per_epoch).enumerate() {
             let slot_committees = state.calculate_crosslink_committees_at_slot(
                 slot,
                 false,

eth2/types/src/beacon_state/helpers.rs

@@ -0,0 +1,20 @@
+use crate::*;
+
+/// Verify ``bitfield`` against the ``committee_size``.
+///
+/// Is title `verify_bitfield` in spec.
+///
+/// Spec v0.4.0
+pub fn verify_bitfield_length(bitfield: &Bitfield, committee_size: usize) -> bool {
+    if bitfield.num_bytes() != ((committee_size + 7) / 8) {
+        return false;
+    }
+
+    for i in committee_size..(bitfield.num_bytes() * 8) {
+        if bitfield.get(i).expect("Impossible due to previous check.") {
+            return false;
+        }
+    }
+
+    true
+}

eth2/types/src/beacon_state/tests.rs

@@ -2,74 +2,12 @@
 
 use super::*;
 use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-use crate::{
-    BeaconState, BeaconStateError, ChainSpec, Deposit, DepositData, DepositInput, Eth1Data,
-    Hash256, Keypair,
-};
-use bls::create_proof_of_possession;
+use crate::{BeaconState, ChainSpec};
 use ssz::{ssz_encode, Decodable};
 
-struct BeaconStateTestBuilder {
-    pub genesis_time: u64,
-    pub initial_validator_deposits: Vec<Deposit>,
-    pub latest_eth1_data: Eth1Data,
-    pub spec: ChainSpec,
-    pub keypairs: Vec<Keypair>,
-}
-
-impl BeaconStateTestBuilder {
-    pub fn with_random_validators(validator_count: usize) -> Self {
-        let genesis_time = 10_000_000;
-        let keypairs: Vec<Keypair> = (0..validator_count)
-            .collect::<Vec<usize>>()
-            .iter()
-            .map(|_| Keypair::random())
-            .collect();
-        let initial_validator_deposits = keypairs
-            .iter()
-            .map(|keypair| Deposit {
-                branch: vec![], // branch verification is not specified.
-                index: 0,       // index verification is not specified.
-                deposit_data: DepositData {
-                    amount: 32_000_000_000, // 32 ETH (in Gwei)
-                    timestamp: genesis_time - 1,
-                    deposit_input: DepositInput {
-                        pubkey: keypair.pk.clone(),
-                        withdrawal_credentials: Hash256::zero(), // Withdrawal not possible.
-                        proof_of_possession: create_proof_of_possession(&keypair),
-                    },
-                },
-            })
-            .collect();
-        let latest_eth1_data = Eth1Data {
-            deposit_root: Hash256::zero(),
-            block_hash: Hash256::zero(),
-        };
-        let spec = ChainSpec::foundation();
-
-        Self {
-            genesis_time,
-            initial_validator_deposits,
-            latest_eth1_data,
-            spec,
-            keypairs,
-        }
-    }
-
-    pub fn build(&self) -> Result<BeaconState, BeaconStateError> {
-        BeaconState::genesis(
-            self.genesis_time,
-            self.initial_validator_deposits.clone(),
-            self.latest_eth1_data.clone(),
-            &self.spec,
-        )
-    }
-}
-
 #[test]
 pub fn can_produce_genesis_block() {
-    let builder = BeaconStateTestBuilder::with_random_validators(2);
-
+    let mut builder = BeaconStateBuilder::new(2);
     builder.build().unwrap();
 }
 
@@ -79,10 +17,12 @@ pub fn can_produce_genesis_block() {
 pub fn get_attestation_participants_consistency() {
     let mut rng = XorShiftRng::from_seed([42; 16]);
 
-    let mut builder = BeaconStateTestBuilder::with_random_validators(8);
+    let mut builder = BeaconStateBuilder::new(8);
     builder.spec = ChainSpec::few_validators();
 
-    let mut state = builder.build().unwrap();
+    builder.build().unwrap();
+
+    let mut state = builder.cloned_state();
     let spec = builder.spec.clone();
 
     state
@@ -95,8 +35,8 @@ pub fn get_attestation_participants_consistency() {
 
     for slot in state
         .slot
-        .epoch(spec.epoch_length)
-        .slot_iter(spec.epoch_length)
+        .epoch(spec.slots_per_epoch)
+        .slot_iter(spec.slots_per_epoch)
     {
         let committees = state.get_crosslink_committees_at_slot(slot, &spec).unwrap();
 

eth2/types/src/chain_spec.rs

@@ -1,11 +1,20 @@
-use crate::{Address, Epoch, Hash256, Slot};
+use crate::{Address, Epoch, Fork, Hash256, Slot};
 use bls::Signature;
 
 const GWEI: u64 = 1_000_000_000;
 
+pub enum Domain {
+    Deposit,
+    Attestation,
+    Proposal,
+    Exit,
+    Randao,
+    Transfer,
+}
+
 /// Holds all the "constants" for a BeaconChain.
 ///
-/// Spec v0.2.0
+/// Spec v0.4.0
 #[derive(PartialEq, Debug, Clone)]
 pub struct ChainSpec {
     /*
@@ -16,7 +25,7 @@ pub struct ChainSpec {
     pub max_balance_churn_quotient: u64,
     pub beacon_chain_shard_number: u64,
     pub max_indices_per_slashable_vote: u64,
-    pub max_withdrawals_per_epoch: u64,
+    pub max_exit_dequeues_per_epoch: u64,
     pub shuffle_round_count: u8,
 
     /*
@@ -48,29 +57,30 @@ pub struct ChainSpec {
     /*
      * Time parameters
      */
-    pub slot_duration: u64,
+    pub seconds_per_slot: u64,
     pub min_attestation_inclusion_delay: u64,
-    pub epoch_length: u64,
-    pub seed_lookahead: Epoch,
-    pub entry_exit_delay: u64,
-    pub eth1_data_voting_period: u64,
-    pub min_validator_withdrawal_epochs: Epoch,
+    pub slots_per_epoch: u64,
+    pub min_seed_lookahead: Epoch,
+    pub activation_exit_delay: u64,
+    pub epochs_per_eth1_voting_period: u64,
+    pub min_validator_withdrawability_delay: Epoch,
 
     /*
      * State list lengths
      */
     pub latest_block_roots_length: usize,
     pub latest_randao_mixes_length: usize,
-    pub latest_index_roots_length: usize,
-    pub latest_penalized_exit_length: usize,
+    pub latest_active_index_roots_length: usize,
+    pub latest_slashed_exit_length: usize,
 
     /*
      * Reward and penalty quotients
      */
     pub base_reward_quotient: u64,
     pub whistleblower_reward_quotient: u64,
-    pub includer_reward_quotient: u64,
+    pub attestation_inclusion_reward_quotient: u64,
     pub inactivity_penalty_quotient: u64,
+    pub min_penalty_quotient: u64,
 
     /*
      * Max operations per block
@@ -79,29 +89,63 @@ pub struct ChainSpec {
     pub max_attester_slashings: u64,
     pub max_attestations: u64,
     pub max_deposits: u64,
-    pub max_exits: u64,
+    pub max_voluntary_exits: u64,
+    pub max_transfers: u64,
 
     /*
      * Signature domains
+     *
+     * Fields should be private to prevent accessing a domain that hasn't been modified to suit
+     * some `Fork`.
+     *
+     * Use `ChainSpec::get_domain(..)` to access these values.
      */
-    pub domain_deposit: u64,
-    pub domain_attestation: u64,
-    pub domain_proposal: u64,
-    pub domain_exit: u64,
-    pub domain_randao: u64,
+    domain_deposit: u64,
+    domain_attestation: u64,
+    domain_proposal: u64,
+    domain_exit: u64,
+    domain_randao: u64,
+    domain_transfer: u64,
 }
 
 impl ChainSpec {
-    /// Returns a `ChainSpec` compatible with the specification from Ethereum Foundation.
+    /// Return the number of committees in one epoch.
     ///
-    /// Of course, the actual foundation specs are unknown at this point so these are just a rough
-    /// estimate.
+    /// Spec v0.4.0
+    pub fn get_epoch_committee_count(&self, active_validator_count: usize) -> u64 {
+        std::cmp::max(
+            1,
+            std::cmp::min(
+                self.shard_count / self.slots_per_epoch,
+                active_validator_count as u64 / self.slots_per_epoch / self.target_committee_size,
+            ),
+        ) * self.slots_per_epoch
+    }
+
+    /// Get the domain number that represents the fork meta and signature domain.
     ///
-    /// Spec v0.2.0
+    /// Spec v0.4.0
+    pub fn get_domain(&self, epoch: Epoch, domain: Domain, fork: &Fork) -> u64 {
+        let domain_constant = match domain {
+            Domain::Deposit => self.domain_deposit,
+            Domain::Attestation => self.domain_attestation,
+            Domain::Proposal => self.domain_proposal,
+            Domain::Exit => self.domain_exit,
+            Domain::Randao => self.domain_randao,
+            Domain::Transfer => self.domain_transfer,
+        };
+
+        let fork_version = fork.get_fork_version(epoch);
+        fork_version * u64::pow(2, 32) + domain_constant
+    }
+
+    /// Returns a `ChainSpec` compatible with the Ethereum Foundation specification.
+    ///
+    /// Spec v0.4.0
     pub fn foundation() -> Self {
-        let genesis_slot = Slot::new(2_u64.pow(19));
-        let epoch_length = 64;
-        let genesis_epoch = genesis_slot.epoch(epoch_length);
+        let genesis_slot = Slot::new(2_u64.pow(32));
+        let slots_per_epoch = 64;
+        let genesis_epoch = genesis_slot.epoch(slots_per_epoch);
 
         Self {
             /*
@@ -112,7 +156,7 @@ impl ChainSpec {
             max_balance_churn_quotient: 32,
             beacon_chain_shard_number: u64::max_value(),
             max_indices_per_slashable_vote: 4_096,
-            max_withdrawals_per_epoch: 4,
+            max_exit_dequeues_per_epoch: 4,
             shuffle_round_count: 90,
 
             /*
@@ -133,7 +177,7 @@ impl ChainSpec {
              * Initial Values
              */
             genesis_fork_version: 0,
-            genesis_slot: Slot::new(2_u64.pow(19)),
+            genesis_slot,
             genesis_epoch,
             genesis_start_shard: 0,
             far_future_epoch: Epoch::new(u64::max_value()),
@@ -144,29 +188,30 @@ impl ChainSpec {
             /*
              * Time parameters
              */
-            slot_duration: 6,
+            seconds_per_slot: 6,
             min_attestation_inclusion_delay: 4,
-            epoch_length,
-            seed_lookahead: Epoch::new(1),
-            entry_exit_delay: 4,
-            eth1_data_voting_period: 16,
-            min_validator_withdrawal_epochs: Epoch::new(256),
+            slots_per_epoch,
+            min_seed_lookahead: Epoch::new(1),
+            activation_exit_delay: 4,
+            epochs_per_eth1_voting_period: 16,
+            min_validator_withdrawability_delay: Epoch::new(256),
 
             /*
              * State list lengths
              */
             latest_block_roots_length: 8_192,
             latest_randao_mixes_length: 8_192,
-            latest_index_roots_length: 8_192,
-            latest_penalized_exit_length: 8_192,
+            latest_active_index_roots_length: 8_192,
+            latest_slashed_exit_length: 8_192,
 
             /*
              * Reward and penalty quotients
              */
             base_reward_quotient: 32,
             whistleblower_reward_quotient: 512,
-            includer_reward_quotient: 8,
+            attestation_inclusion_reward_quotient: 8,
             inactivity_penalty_quotient: 16_777_216,
+            min_penalty_quotient: 32,
 
             /*
              * Max operations per block
@@ -175,7 +220,8 @@ impl ChainSpec {
             max_attester_slashings: 1,
             max_attestations: 128,
             max_deposits: 16,
-            max_exits: 16,
+            max_voluntary_exits: 16,
+            max_transfers: 16,
 
             /*
              * Signature domains
@@ -185,25 +231,24 @@ impl ChainSpec {
             domain_proposal: 2,
             domain_exit: 3,
             domain_randao: 4,
+            domain_transfer: 5,
         }
     }
-}
 
-impl ChainSpec {
     /// Returns a `ChainSpec` compatible with the specification suitable for 8 validators.
     ///
-    /// Spec v0.2.0
+    /// Spec v0.4.0
     pub fn few_validators() -> Self {
-        let genesis_slot = Slot::new(2_u64.pow(19));
-        let epoch_length = 8;
-        let genesis_epoch = genesis_slot.epoch(epoch_length);
+        let genesis_slot = Slot::new(2_u64.pow(32));
+        let slots_per_epoch = 8;
+        let genesis_epoch = genesis_slot.epoch(slots_per_epoch);
 
         Self {
             shard_count: 8,
             target_committee_size: 1,
             genesis_slot,
             genesis_epoch,
-            epoch_length,
+            slots_per_epoch,
             ..ChainSpec::foundation()
         }
     }

eth2/types/src/crosslink.rs

@@ -5,22 +5,15 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+/// Specifies the block hash for a shard at an epoch.
+///
+/// Spec v0.4.0
 #[derive(
     Debug, Clone, PartialEq, Default, Serialize, Hash, Encode, Decode, TreeHash, TestRandom,
 )]
 pub struct Crosslink {
     pub epoch: Epoch,
-    pub shard_block_root: Hash256,
-}
-
-impl Crosslink {
-    /// Generates a new instance where `dynasty` and `hash` are both zero.
-    pub fn zero() -> Self {
-        Self {
-            epoch: Epoch::new(0),
-            shard_block_root: Hash256::zero(),
-        }
-    }
+    pub crosslink_data_root: Hash256,
 }
 
 #[cfg(test)]

eth2/types/src/deposit.rs

@@ -5,6 +5,9 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+/// A deposit to potentially become a beacon chain validator.
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct Deposit {
     pub branch: Vec<Hash256>,

eth2/types/src/deposit_data.rs

@@ -5,6 +5,9 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+/// Data generated by the deposit contract.
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct DepositData {
     pub amount: u64,

eth2/types/src/deposit_input.rs

@@ -6,6 +6,9 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+/// The data supplied by the user to the deposit contract.
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct DepositInput {
     pub pubkey: PublicKey,

eth2/types/src/eth1_data.rs

@@ -5,7 +5,9 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
-// Note: this is refer to as DepositRootVote in specs
+/// Contains data obtained from the Eth1 chain.
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct Eth1Data {
     pub deposit_root: Hash256,

eth2/types/src/eth1_data_vote.rs

@@ -5,7 +5,9 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
-// Note: this is refer to as DepositRootVote in specs
+/// A summation of votes for some `Eth1Data`.
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Default, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct Eth1DataVote {
     pub eth1_data: Eth1Data,

eth2/types/src/fork.rs

@@ -4,6 +4,9 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+/// Specifies a fork of the `BeaconChain`, to prevent replay attacks.
+///
+/// Spec v0.4.0
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct Fork {
     pub previous_version: u64,
@@ -13,18 +16,14 @@ pub struct Fork {
 
 impl Fork {
     /// Return the fork version of the given ``epoch``.
+    ///
+    /// Spec v0.4.0
     pub fn get_fork_version(&self, epoch: Epoch) -> u64 {
         if epoch < self.epoch {
             return self.previous_version;
         }
         self.current_version
     }
-
-    /// Get the domain number that represents the fork meta and signature domain.
-    pub fn get_domain(&self, epoch: Epoch, domain_type: u64) -> u64 {
-        let fork_version = self.get_fork_version(epoch);
-        fork_version * u64::pow(2, 32) + domain_type
-    }
 }
 
 #[cfg(test)]

eth2/types/src/lib.rs

@@ -7,7 +7,6 @@ pub mod attester_slashing;
 pub mod beacon_block;
 pub mod beacon_block_body;
 pub mod beacon_state;
-pub mod casper_slashing;
 pub mod chain_spec;
 pub mod crosslink;
 pub mod deposit;
@@ -15,23 +14,22 @@ pub mod deposit_data;
 pub mod deposit_input;
 pub mod eth1_data;
 pub mod eth1_data_vote;
-pub mod exit;
 pub mod fork;
 pub mod free_attestation;
 pub mod pending_attestation;
-pub mod proposal_signed_data;
+pub mod proposal;
 pub mod proposer_slashing;
 pub mod readers;
 pub mod shard_reassignment_record;
 pub mod slashable_attestation;
-pub mod slashable_vote_data;
+pub mod transfer;
+pub mod voluntary_exit;
 #[macro_use]
 pub mod slot_epoch_macros;
 pub mod slot_epoch;
 pub mod slot_height;
 pub mod validator;
 pub mod validator_registry;
-pub mod validator_registry_delta_block;
 
 use ethereum_types::{H160, H256, U256};
 use std::collections::HashMap;
@@ -42,29 +40,25 @@ pub use crate::attestation_data_and_custody_bit::AttestationDataAndCustodyBit;
 pub use crate::attester_slashing::AttesterSlashing;
 pub use crate::beacon_block::BeaconBlock;
 pub use crate::beacon_block_body::BeaconBlockBody;
-pub use crate::beacon_state::{
-    BeaconState, Error as BeaconStateError, InclusionError, RelativeEpoch,
-};
-pub use crate::casper_slashing::CasperSlashing;
-pub use crate::chain_spec::ChainSpec;
+pub use crate::beacon_state::{BeaconState, Error as BeaconStateError, RelativeEpoch};
+pub use crate::chain_spec::{ChainSpec, Domain};
 pub use crate::crosslink::Crosslink;
 pub use crate::deposit::Deposit;
 pub use crate::deposit_data::DepositData;
 pub use crate::deposit_input::DepositInput;
 pub use crate::eth1_data::Eth1Data;
 pub use crate::eth1_data_vote::Eth1DataVote;
-pub use crate::exit::Exit;
 pub use crate::fork::Fork;
 pub use crate::free_attestation::FreeAttestation;
 pub use crate::pending_attestation::PendingAttestation;
-pub use crate::proposal_signed_data::ProposalSignedData;
+pub use crate::proposal::Proposal;
 pub use crate::proposer_slashing::ProposerSlashing;
 pub use crate::slashable_attestation::SlashableAttestation;
-pub use crate::slashable_vote_data::SlashableVoteData;
 pub use crate::slot_epoch::{Epoch, Slot};
 pub use crate::slot_height::SlotHeight;
-pub use crate::validator::{StatusFlags as ValidatorStatusFlags, Validator};
-pub use crate::validator_registry_delta_block::ValidatorRegistryDeltaBlock;
+pub use crate::transfer::Transfer;
+pub use crate::validator::Validator;
+pub use crate::voluntary_exit::VoluntaryExit;
 
 pub type Hash256 = H256;
 pub type Address = H160;

eth2/types/src/pending_attestation.rs

@@ -5,6 +5,9 @@ use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+/// An attestation that has been included in the state but not yet fully processed.
+///
+/// Spec v0.4.0
 #[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct PendingAttestation {
     pub aggregation_bitfield: Bitfield,

eth2/types/src/proposal.rs

@@ -0,0 +1,78 @@
+use crate::test_utils::TestRandom;
+use crate::{Hash256, Slot};
+use bls::Signature;
+use rand::RngCore;
+use serde_derive::Serialize;
+use ssz::TreeHash;
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
+use test_random_derive::TestRandom;
+
+/// A proposal for some shard or beacon block.
+///
+/// Spec v0.4.0
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+pub struct Proposal {
+    pub slot: Slot,
+    /// Shard number (spec.beacon_chain_shard_number for beacon chain)
+    pub shard: u64,
+    pub block_root: Hash256,
+    pub signature: Signature,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+    use ssz::{ssz_encode, Decodable, SignedRoot, TreeHash};
+
+    #[test]
+    pub fn test_ssz_round_trip() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Proposal::random_for_test(&mut rng);
+
+        let bytes = ssz_encode(&original);
+        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
+
+        assert_eq!(original, decoded);
+    }
+
+    #[test]
+    pub fn test_hash_tree_root_internal() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Proposal::random_for_test(&mut rng);
+
+        let result = original.hash_tree_root_internal();
+
+        assert_eq!(result.len(), 32);
+        // TODO: Add further tests
+        // https://github.com/sigp/lighthouse/issues/170
+    }
+
+    #[derive(TreeHash)]
+    struct SignedProposal {
+        pub slot: Slot,
+        pub shard: u64,
+        pub block_root: Hash256,
+    }
+
+    impl Into<SignedProposal> for Proposal {
+        fn into(self) -> SignedProposal {
+            SignedProposal {
+                slot: self.slot,
+                shard: self.shard,
+                block_root: self.block_root,
+            }
+        }
+    }
+
+    #[test]
+    pub fn test_signed_root() {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let original = Proposal::random_for_test(&mut rng);
+
+        let other: SignedProposal = original.clone().into();
+
+        assert_eq!(original.signed_root(), other.hash_tree_root());
+    }
+
+}

eth2/types/src/proposal_signed_data.rs

@@ -15,29 +15,6 @@ pub struct ProposalSignedData {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::{ssz_encode, Decodable, TreeHash};
 
-    #[test]
-    pub fn test_ssz_round_trip() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = ProposalSignedData::random_for_test(&mut rng);
-
-        let bytes = ssz_encode(&original);
-        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
-
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    pub fn test_hash_tree_root_internal() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = ProposalSignedData::random_for_test(&mut rng);
-
-        let result = original.hash_tree_root_internal();
-
-        assert_eq!(result.len(), 32);
-        // TODO: Add further tests
-        // https://github.com/sigp/lighthouse/issues/170
-    }
+    ssz_tests!(ProposalSignedData);
 }

eth2/types/src/proposer_slashing.rs

@@ -1,18 +1,22 @@
-use super::ProposalSignedData;
+use super::Proposal;
 use crate::test_utils::TestRandom;
-use bls::Signature;
 use rand::RngCore;
 use serde_derive::Serialize;
 use ssz_derive::{Decode, Encode, TreeHash};
 use test_random_derive::TestRandom;
 
+mod builder;
+
+pub use builder::ProposerSlashingBuilder;
+
+/// Two conflicting proposals from the same proposer (validator).
+///
+/// Spec v0.4.0
 #[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
 pub struct ProposerSlashing {
     pub proposer_index: u64,
-    pub proposal_data_1: ProposalSignedData,
-    pub proposal_signature_1: Signature,
-    pub proposal_data_2: ProposalSignedData,
-    pub proposal_signature_2: Signature,
+    pub proposal_1: Proposal,
+    pub proposal_2: Proposal,
 }
 
 #[cfg(test)]

eth2/types/src/proposer_slashing/builder.rs

@@ -0,0 +1,57 @@
+use crate::*;
+use ssz::SignedRoot;
+
+/// Builds a `ProposerSlashing`.
+pub struct ProposerSlashingBuilder();
+
+impl ProposerSlashingBuilder {
+    /// Builds a `ProposerSlashing` that is a double vote.
+    ///
+    /// The `signer` function is used to sign the double-vote and accepts:
+    ///
+    /// - `validator_index: u64`
+    /// - `message: &[u8]`
+    /// - `epoch: Epoch`
+    /// - `domain: Domain`
+    ///
+    /// Where domain is a domain "constant" (e.g., `spec.domain_attestation`).
+    pub fn double_vote<F>(proposer_index: u64, signer: F, spec: &ChainSpec) -> ProposerSlashing
+    where
+        F: Fn(u64, &[u8], Epoch, Domain) -> Signature,
+    {
+        let slot = Slot::new(0);
+        let shard = 0;
+
+        let mut proposal_1 = Proposal {
+            slot,
+            shard,
+            block_root: Hash256::from_low_u64_le(1),
+            signature: Signature::empty_signature(),
+        };
+
+        let mut proposal_2 = Proposal {
+            slot,
+            shard,
+            block_root: Hash256::from_low_u64_le(2),
+            signature: Signature::empty_signature(),
+        };
+
+        proposal_1.signature = {
+            let message = proposal_1.signed_root();
+            let epoch = slot.epoch(spec.slots_per_epoch);
+            signer(proposer_index, &message[..], epoch, Domain::Proposal)
+        };
+
+        proposal_2.signature = {
+            let message = proposal_2.signed_root();
+            let epoch = slot.epoch(spec.slots_per_epoch);
+            signer(proposer_index, &message[..], epoch, Domain::Proposal)
+        };
+
+        ProposerSlashing {
+            proposer_index,
+            proposal_1,
+            proposal_2,
+        }
+    }
+}

eth2/types/src/readers/block_reader.rs

@@ -13,7 +13,6 @@ pub trait BeaconBlockReader: Debug + PartialEq {
     fn slot(&self) -> Slot;
     fn parent_root(&self) -> Hash256;
     fn state_root(&self) -> Hash256;
-    fn canonical_root(&self) -> Hash256;
     fn into_beacon_block(self) -> Option<BeaconBlock>;
 }
 
@@ -30,10 +29,6 @@ impl BeaconBlockReader for BeaconBlock {
         self.state_root
     }
 
-    fn canonical_root(&self) -> Hash256 {
-        self.canonical_root()
-    }
-
     fn into_beacon_block(self) -> Option<BeaconBlock> {
         Some(self)
     }

eth2/types/src/readers/state_reader.rs

@@ -1,4 +1,4 @@
-use crate::{BeaconState, Hash256, Slot};
+use crate::{BeaconState, Slot};
 use std::fmt::Debug;
 
 /// The `BeaconStateReader` provides interfaces for reading a subset of fields of a `BeaconState`.
@@ -11,7 +11,6 @@ use std::fmt::Debug;
 /// "future proofing".
 pub trait BeaconStateReader: Debug + PartialEq {
     fn slot(&self) -> Slot;
-    fn canonical_root(&self) -> Hash256;
     fn into_beacon_state(self) -> Option<BeaconState>;
 }
 
@@ -20,10 +19,6 @@ impl BeaconStateReader for BeaconState {
         self.slot
     }
 
-    fn canonical_root(&self) -> Hash256 {
-        self.canonical_root()
-    }
-
     fn into_beacon_state(self) -> Option<BeaconState> {
         Some(self)
     }

eth2/types/src/slashable_attestation.rs

@@ -1,23 +1,125 @@
-use crate::{test_utils::TestRandom, AggregateSignature, AttestationData, Bitfield};
+use crate::{test_utils::TestRandom, AggregateSignature, AttestationData, Bitfield, ChainSpec};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz_derive::{Decode, Encode, TreeHash};
+use ssz::TreeHash;
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
+/// Details an attestation that can be slashable.
+///
+/// To be included in an `AttesterSlashing`.
+///
+/// Spec v0.4.0
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
 pub struct SlashableAttestation {
+    /// Lists validator registry indices, not committee indices.
     pub validator_indices: Vec<u64>,
     pub data: AttestationData,
     pub custody_bitfield: Bitfield,
     pub aggregate_signature: AggregateSignature,
 }
 
+impl SlashableAttestation {
+    /// Check if ``attestation_data_1`` and ``attestation_data_2`` have the same target.
+    ///
+    /// Spec v0.4.0
+    pub fn is_double_vote(&self, other: &SlashableAttestation, spec: &ChainSpec) -> bool {
+        self.data.slot.epoch(spec.slots_per_epoch) == other.data.slot.epoch(spec.slots_per_epoch)
+    }
+
+    /// Check if ``attestation_data_1`` surrounds ``attestation_data_2``.
+    ///
+    /// Spec v0.4.0
+    pub fn is_surround_vote(&self, other: &SlashableAttestation, spec: &ChainSpec) -> bool {
+        let source_epoch_1 = self.data.justified_epoch;
+        let source_epoch_2 = other.data.justified_epoch;
+        let target_epoch_1 = self.data.slot.epoch(spec.slots_per_epoch);
+        let target_epoch_2 = other.data.slot.epoch(spec.slots_per_epoch);
+
+        (source_epoch_1 < source_epoch_2) & (target_epoch_2 < target_epoch_1)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::chain_spec::ChainSpec;
+    use crate::slot_epoch::{Epoch, Slot};
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
     use ssz::{ssz_encode, Decodable, TreeHash};
 
+    #[test]
+    pub fn test_is_double_vote_true() {
+        let spec = ChainSpec::foundation();
+        let slashable_vote_first = create_slashable_attestation(1, 1, &spec);
+        let slashable_vote_second = create_slashable_attestation(1, 1, &spec);
+
+        assert_eq!(
+            slashable_vote_first.is_double_vote(&slashable_vote_second, &spec),
+            true
+        )
+    }
+
+    #[test]
+    pub fn test_is_double_vote_false() {
+        let spec = ChainSpec::foundation();
+        let slashable_vote_first = create_slashable_attestation(1, 1, &spec);
+        let slashable_vote_second = create_slashable_attestation(2, 1, &spec);
+
+        assert_eq!(
+            slashable_vote_first.is_double_vote(&slashable_vote_second, &spec),
+            false
+        );
+    }
+
+    #[test]
+    pub fn test_is_surround_vote_true() {
+        let spec = ChainSpec::foundation();
+        let slashable_vote_first = create_slashable_attestation(2, 1, &spec);
+        let slashable_vote_second = create_slashable_attestation(1, 2, &spec);
+
+        assert_eq!(
+            slashable_vote_first.is_surround_vote(&slashable_vote_second, &spec),
+            true
+        );
+    }
+
+    #[test]
+    pub fn test_is_surround_vote_true_realistic() {
+        let spec = ChainSpec::foundation();
+        let slashable_vote_first = create_slashable_attestation(4, 1, &spec);
+        let slashable_vote_second = create_slashable_attestation(3, 2, &spec);
+
+        assert_eq!(
+            slashable_vote_first.is_surround_vote(&slashable_vote_second, &spec),
+            true
+        );
+    }
+
+    #[test]
+    pub fn test_is_surround_vote_false_source_epoch_fails() {
+        let spec = ChainSpec::foundation();
+        let slashable_vote_first = create_slashable_attestation(2, 2, &spec);
+        let slashable_vote_second = create_slashable_attestation(1, 1, &spec);
+
+        assert_eq!(
+            slashable_vote_first.is_surround_vote(&slashable_vote_second, &spec),
+            false
+        );
+    }
+
+    #[test]
+    pub fn test_is_surround_vote_false_target_epoch_fails() {
+        let spec = ChainSpec::foundation();
+        let slashable_vote_first = create_slashable_attestation(1, 1, &spec);
+        let slashable_vote_second = create_slashable_attestation(2, 2, &spec);
+
+        assert_eq!(
+            slashable_vote_first.is_surround_vote(&slashable_vote_second, &spec),
+            false
+        );
+    }
+
     #[test]
     pub fn test_ssz_round_trip() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
@@ -40,4 +142,17 @@ mod tests {
         // TODO: Add further tests
         // https://github.com/sigp/lighthouse/issues/170
     }
+
+    fn create_slashable_attestation(
+        slot_factor: u64,
+        justified_epoch: u64,
+        spec: &ChainSpec,
+    ) -> SlashableAttestation {
+        let mut rng = XorShiftRng::from_seed([42; 16]);
+        let mut slashable_vote = SlashableAttestation::random_for_test(&mut rng);
+
+        slashable_vote.data.slot = Slot::new(slot_factor * spec.slots_per_epoch);
+        slashable_vote.data.justified_epoch = Epoch::new(justified_epoch);
+        slashable_vote
+    }
 }

eth2/types/src/slashable_vote_data.rs

@@ -42,7 +42,6 @@ mod tests {
     use crate::chain_spec::ChainSpec;
     use crate::slot_epoch::{Epoch, Slot};
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::{ssz_encode, Decodable, TreeHash};
 
     #[test]
     pub fn test_is_double_vote_true() {
@@ -116,28 +115,7 @@ mod tests {
         );
     }
 
-    #[test]
-    pub fn test_ssz_round_trip() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = SlashableVoteData::random_for_test(&mut rng);
-
-        let bytes = ssz_encode(&original);
-        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
-
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    pub fn test_hash_tree_root_internal() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = SlashableVoteData::random_for_test(&mut rng);
-
-        let result = original.hash_tree_root_internal();
-
-        assert_eq!(result.len(), 32);
-        // TODO: Add further tests
-        // https://github.com/sigp/lighthouse/issues/170
-    }
+    ssz_tests!(SlashableVoteData);
 
     fn create_slashable_vote_data(
         slot_factor: u64,

eth2/types/src/slot_epoch.rs

@@ -35,8 +35,8 @@ impl Slot {
         Slot(slot)
     }
 
-    pub fn epoch(self, epoch_length: u64) -> Epoch {
-        Epoch::from(self.0 / epoch_length)
+    pub fn epoch(self, slots_per_epoch: u64) -> Epoch {
+        Epoch::from(self.0 / slots_per_epoch)
     }
 
     pub fn height(self, genesis_slot: Slot) -> SlotHeight {
@@ -57,24 +57,24 @@ impl Epoch {
         Epoch(u64::max_value())
     }
 
-    pub fn start_slot(self, epoch_length: u64) -> Slot {
-        Slot::from(self.0.saturating_mul(epoch_length))
+    pub fn start_slot(self, slots_per_epoch: u64) -> Slot {
+        Slot::from(self.0.saturating_mul(slots_per_epoch))
     }
 
-    pub fn end_slot(self, epoch_length: u64) -> Slot {
+    pub fn end_slot(self, slots_per_epoch: u64) -> Slot {
         Slot::from(
             self.0
                 .saturating_add(1)
-                .saturating_mul(epoch_length)
+                .saturating_mul(slots_per_epoch)
                 .saturating_sub(1),
         )
     }
 
-    pub fn slot_iter(&self, epoch_length: u64) -> SlotIter {
+    pub fn slot_iter(&self, slots_per_epoch: u64) -> SlotIter {
         SlotIter {
             current_iteration: 0,
             epoch: self,
-            epoch_length,
+            slots_per_epoch,
         }
     }
 }
@@ -82,17 +82,17 @@ impl Epoch {
 pub struct SlotIter<'a> {
     current_iteration: u64,
     epoch: &'a Epoch,
-    epoch_length: u64,
+    slots_per_epoch: u64,
 }
 
 impl<'a> Iterator for SlotIter<'a> {
     type Item = Slot;
 
     fn next(&mut self) -> Option<Slot> {
-        if self.current_iteration >= self.epoch_length {
+        if self.current_iteration >= self.slots_per_epoch {
             None
         } else {
-            let start_slot = self.epoch.start_slot(self.epoch_length);
+            let start_slot = self.epoch.start_slot(self.slots_per_epoch);
             let previous = self.current_iteration;
             self.current_iteration += 1;
             Some(start_slot + previous)
@@ -119,18 +119,18 @@ mod epoch_tests {
 
     #[test]
     fn slot_iter() {
-        let epoch_length = 8;
+        let slots_per_epoch = 8;
 
         let epoch = Epoch::new(0);
 
         let mut slots = vec![];
-        for slot in epoch.slot_iter(epoch_length) {
+        for slot in epoch.slot_iter(slots_per_epoch) {
             slots.push(slot);
         }
 
-        assert_eq!(slots.len(), epoch_length as usize);
+        assert_eq!(slots.len(), slots_per_epoch as usize);
 
-        for i in 0..epoch_length {
+        for i in 0..slots_per_epoch {
             assert_eq!(Slot::from(i), slots[i as usize])
         }
     }

eth2/types/src/slot_epoch_macros.rs

@@ -20,25 +20,6 @@ macro_rules! impl_from_into_u64 {
     };
 }
 
-// need to truncate for some fork-choice algorithms
-macro_rules! impl_into_u32 {
-    ($main: ident) => {
-        impl Into<u32> 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
-            }
-        }
-    };
-}
-
 macro_rules! impl_from_into_usize {
     ($main: ident) => {
         impl From<usize> for $main {

eth2/types/src/slot_height.rs

@@ -13,7 +13,6 @@ use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, Sub, SubAssi
 pub struct SlotHeight(u64);
 
 impl_common!(SlotHeight);
-impl_into_u32!(SlotHeight); // SlotHeight can be converted to u32
 
 impl SlotHeight {
     pub fn new(slot: u64) -> SlotHeight {
@@ -24,8 +23,8 @@ impl SlotHeight {
         Slot::from(self.0.saturating_add(genesis_slot.as_u64()))
     }
 
-    pub fn epoch(self, genesis_slot: u64, epoch_length: u64) -> Epoch {
-        Epoch::from(self.0.saturating_add(genesis_slot) / epoch_length)
+    pub fn epoch(self, genesis_slot: u64, slots_per_epoch: u64) -> Epoch {
+        Epoch::from(self.0.saturating_add(genesis_slot) / slots_per_epoch)
     }
 
     pub fn max_value() -> SlotHeight {

eth2/types/src/test_utils/address.rs

@@ -6,6 +6,6 @@ impl<T: RngCore> TestRandom<T> for Address {
     fn random_for_test(rng: &mut T) -> Self {
         let mut key_bytes = vec![0; 20];
         rng.fill_bytes(&mut key_bytes);
-        Address::from(&key_bytes[..])
+        Address::from_slice(&key_bytes[..])
     }
 }

eth2/types/src/test_utils/hash256.rs

@@ -6,6 +6,6 @@ impl<T: RngCore> TestRandom<T> for Hash256 {
     fn random_for_test(rng: &mut T) -> Self {
         let mut key_bytes = vec![0; 32];
         rng.fill_bytes(&mut key_bytes);
-        Hash256::from(&key_bytes[..])
+        Hash256::from_slice(&key_bytes[..])
     }
 }

eth2/types/src/test_utils/macros.rs

@@ -0,0 +1,34 @@
+#[cfg(test)]
+#[macro_export]
+macro_rules! ssz_tests {
+    ($type: ident) => {
+        #[test]
+        pub fn test_ssz_round_trip() {
+            use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+            use ssz::{ssz_encode, Decodable};
+
+            let mut rng = XorShiftRng::from_seed([42; 16]);
+            let original = $type::random_for_test(&mut rng);
+
+            let bytes = ssz_encode(&original);
+            let (decoded, _) = $type::ssz_decode(&bytes, 0).unwrap();
+
+            assert_eq!(original, decoded);
+        }
+
+        #[test]
+        pub fn test_hash_tree_root_internal() {
+            use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
+            use ssz::TreeHash;
+
+            let mut rng = XorShiftRng::from_seed([42; 16]);
+            let original = $type::random_for_test(&mut rng);
+
+            let result = original.hash_tree_root_internal();
+
+            assert_eq!(result.len(), 32);
+            // TODO: Add further tests
+            // https://github.com/sigp/lighthouse/issues/170
+        }
+    };
+}

eth2/types/src/test_utils/mod.rs

@@ -17,6 +17,12 @@ where
     fn random_for_test(rng: &mut T) -> Self;
 }
 
+impl<T: RngCore> TestRandom<T> for bool {
+    fn random_for_test(rng: &mut T) -> Self {
+        (rng.next_u32() % 2) == 1
+    }
+}
+
 impl<T: RngCore> TestRandom<T> for u64 {
     fn random_for_test(rng: &mut T) -> Self {
         rng.next_u64()

eth2/types/src/transfer.rs

@@ -1,14 +1,24 @@
-use super::SlashableVoteData;
+use super::Slot;
 use crate::test_utils::TestRandom;
+use bls::{PublicKey, Signature};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz_derive::{Decode, Encode, TreeHash};
+use ssz::TreeHash;
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
-pub struct CasperSlashing {
-    pub slashable_vote_data_1: SlashableVoteData,
-    pub slashable_vote_data_2: SlashableVoteData,
+/// The data submitted to the deposit contract.
+///
+/// Spec v0.4.0
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+pub struct Transfer {
+    pub from: u64,
+    pub to: u64,
+    pub amount: u64,
+    pub fee: u64,
+    pub slot: Slot,
+    pub pubkey: PublicKey,
+    pub signature: Signature,
 }
 
 #[cfg(test)]
@@ -20,7 +30,7 @@ mod tests {
     #[test]
     pub fn test_ssz_round_trip() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = CasperSlashing::random_for_test(&mut rng);
+        let original = Transfer::random_for_test(&mut rng);
 
         let bytes = ssz_encode(&original);
         let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
@@ -31,7 +41,7 @@ mod tests {
     #[test]
     pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = CasperSlashing::random_for_test(&mut rng);
+        let original = Transfer::random_for_test(&mut rng);
 
         let result = original.hash_tree_root_internal();
 

eth2/types/src/validator.rs

@@ -1,62 +1,37 @@
 use crate::{test_utils::TestRandom, Epoch, Hash256, PublicKey};
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz::{hash, Decodable, DecodeError, Encodable, SszStream, TreeHash};
+use ssz_derive::{Decode, Encode, TreeHash};
+use test_random_derive::TestRandom;
 
-const STATUS_FLAG_INITIATED_EXIT: u8 = 1;
-const STATUS_FLAG_WITHDRAWABLE: u8 = 2;
-
-#[derive(Debug, PartialEq, Clone, Copy, Serialize)]
-pub enum StatusFlags {
-    InitiatedExit,
-    Withdrawable,
-}
-
-struct StatusFlagsDecodeError;
-
-impl From<StatusFlagsDecodeError> for DecodeError {
-    fn from(_: StatusFlagsDecodeError) -> DecodeError {
-        DecodeError::Invalid
-    }
-}
-
-/// Handles the serialization logic for the `status_flags` field of the `Validator`.
-fn status_flag_to_byte(flag: Option<StatusFlags>) -> u8 {
-    if let Some(flag) = flag {
-        match flag {
-            StatusFlags::InitiatedExit => STATUS_FLAG_INITIATED_EXIT,
-            StatusFlags::Withdrawable => STATUS_FLAG_WITHDRAWABLE,
-        }
-    } else {
-        0
-    }
-}
-
-/// Handles the deserialization logic for the `status_flags` field of the `Validator`.
-fn status_flag_from_byte(flag: u8) -> Result<Option<StatusFlags>, StatusFlagsDecodeError> {
-    match flag {
-        0 => Ok(None),
-        1 => Ok(Some(StatusFlags::InitiatedExit)),
-        2 => Ok(Some(StatusFlags::Withdrawable)),
-        _ => Err(StatusFlagsDecodeError),
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize)]
+/// Information about a `BeaconChain` validator.
+///
+/// Spec v0.4.0
+#[derive(Debug, Clone, PartialEq, Serialize, Encode, Decode, TestRandom, TreeHash)]
 pub struct Validator {
     pub pubkey: PublicKey,
     pub withdrawal_credentials: Hash256,
     pub activation_epoch: Epoch,
     pub exit_epoch: Epoch,
-    pub withdrawal_epoch: Epoch,
-    pub penalized_epoch: Epoch,
-    pub status_flags: Option<StatusFlags>,
+    pub withdrawable_epoch: Epoch,
+    pub initiated_exit: bool,
+    pub slashed: bool,
 }
 
 impl Validator {
-    /// This predicate indicates if the validator represented by this record is considered "active" at `slot`.
-    pub fn is_active_at(&self, slot: Epoch) -> bool {
-        self.activation_epoch <= slot && slot < self.exit_epoch
+    /// Returns `true` if the validator is considered active at some epoch.
+    pub fn is_active_at(&self, epoch: Epoch) -> bool {
+        self.activation_epoch <= epoch && epoch < self.exit_epoch
+    }
+
+    /// Returns `true` if the validator is considered exited at some epoch.
+    pub fn is_exited_at(&self, epoch: Epoch) -> bool {
+        self.exit_epoch <= epoch
+    }
+
+    /// Returns `true` if the validator is able to withdraw at some epoch.
+    pub fn is_withdrawable_at(&self, epoch: Epoch) -> bool {
+        self.withdrawable_epoch <= epoch
     }
 }
 
@@ -68,85 +43,9 @@ impl Default for Validator {
             withdrawal_credentials: Hash256::default(),
             activation_epoch: Epoch::from(std::u64::MAX),
             exit_epoch: Epoch::from(std::u64::MAX),
-            withdrawal_epoch: Epoch::from(std::u64::MAX),
-            penalized_epoch: Epoch::from(std::u64::MAX),
-            status_flags: None,
-        }
-    }
-}
-
-impl<T: RngCore> TestRandom<T> for StatusFlags {
-    fn random_for_test(rng: &mut T) -> Self {
-        let options = vec![StatusFlags::InitiatedExit, StatusFlags::Withdrawable];
-        options[(rng.next_u32() as usize) % options.len()]
-    }
-}
-
-impl Encodable for Validator {
-    fn ssz_append(&self, s: &mut SszStream) {
-        s.append(&self.pubkey);
-        s.append(&self.withdrawal_credentials);
-        s.append(&self.activation_epoch);
-        s.append(&self.exit_epoch);
-        s.append(&self.withdrawal_epoch);
-        s.append(&self.penalized_epoch);
-        s.append(&status_flag_to_byte(self.status_flags));
-    }
-}
-
-impl Decodable for Validator {
-    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 (activation_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (exit_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (withdrawal_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (penalized_epoch, i) = <_>::ssz_decode(bytes, i)?;
-        let (status_flags_byte, i): (u8, usize) = <_>::ssz_decode(bytes, i)?;
-
-        let status_flags = status_flag_from_byte(status_flags_byte)?;
-
-        Ok((
-            Self {
-                pubkey,
-                withdrawal_credentials,
-                activation_epoch,
-                exit_epoch,
-                withdrawal_epoch,
-                penalized_epoch,
-                status_flags,
-            },
-            i,
-        ))
-    }
-}
-
-impl TreeHash for Validator {
-    fn hash_tree_root_internal(&self) -> Vec<u8> {
-        let mut result: Vec<u8> = vec![];
-        result.append(&mut self.pubkey.hash_tree_root_internal());
-        result.append(&mut self.withdrawal_credentials.hash_tree_root_internal());
-        result.append(&mut self.activation_epoch.hash_tree_root_internal());
-        result.append(&mut self.exit_epoch.hash_tree_root_internal());
-        result.append(&mut self.withdrawal_epoch.hash_tree_root_internal());
-        result.append(&mut self.penalized_epoch.hash_tree_root_internal());
-        result.append(
-            &mut u64::from(status_flag_to_byte(self.status_flags)).hash_tree_root_internal(),
-        );
-        hash(&result)
-    }
-}
-
-impl<T: RngCore> TestRandom<T> for Validator {
-    fn random_for_test(rng: &mut T) -> Self {
-        Self {
-            pubkey: <_>::random_for_test(rng),
-            withdrawal_credentials: <_>::random_for_test(rng),
-            activation_epoch: <_>::random_for_test(rng),
-            exit_epoch: <_>::random_for_test(rng),
-            withdrawal_epoch: <_>::random_for_test(rng),
-            penalized_epoch: <_>::random_for_test(rng),
-            status_flags: Some(<_>::random_for_test(rng)),
+            withdrawable_epoch: Epoch::from(std::u64::MAX),
+            initiated_exit: false,
+            slashed: false,
         }
     }
 }
@@ -155,7 +54,7 @@ impl<T: RngCore> TestRandom<T> for Validator {
 mod tests {
     use super::*;
     use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::ssz_encode;
+    use ssz::{ssz_encode, Decodable, TreeHash};
 
     #[test]
     pub fn test_ssz_round_trip() {

eth2/types/src/validator_registry.rs

@@ -4,6 +4,8 @@ use super::validator::*;
 use crate::Epoch;
 
 /// Given an indexed sequence of `validators`, return the indices corresponding to validators that are active at `epoch`.
+///
+/// Spec v0.4.0
 pub fn get_active_validator_indices(validators: &[Validator], epoch: Epoch) -> Vec<usize> {
     validators
         .iter()

eth2/types/src/validator_registry_delta_block.rs

@@ -31,29 +31,6 @@ impl Default for ValidatorRegistryDeltaBlock {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::{SeedableRng, TestRandom, XorShiftRng};
-    use ssz::{ssz_encode, Decodable, TreeHash};
 
-    #[test]
-    pub fn test_ssz_round_trip() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = ValidatorRegistryDeltaBlock::random_for_test(&mut rng);
-
-        let bytes = ssz_encode(&original);
-        let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
-
-        assert_eq!(original, decoded);
-    }
-
-    #[test]
-    pub fn test_hash_tree_root_internal() {
-        let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = ValidatorRegistryDeltaBlock::random_for_test(&mut rng);
-
-        let result = original.hash_tree_root_internal();
-
-        assert_eq!(result.len(), 32);
-        // TODO: Add further tests
-        // https://github.com/sigp/lighthouse/issues/170
-    }
+    ssz_tests!(ValidatorRegistryDeltaBlock);
 }

eth2/types/src/voluntary_exit.rs

@@ -2,11 +2,15 @@ use crate::{test_utils::TestRandom, Epoch};
 use bls::Signature;
 use rand::RngCore;
 use serde_derive::Serialize;
-use ssz_derive::{Decode, Encode, TreeHash};
+use ssz::TreeHash;
+use ssz_derive::{Decode, Encode, SignedRoot, TreeHash};
 use test_random_derive::TestRandom;
 
-#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom)]
-pub struct Exit {
+/// An exit voluntarily submitted a validator who wishes to withdraw.
+///
+/// Spec v0.4.0
+#[derive(Debug, PartialEq, Clone, Serialize, Encode, Decode, TreeHash, TestRandom, SignedRoot)]
+pub struct VoluntaryExit {
     pub epoch: Epoch,
     pub validator_index: u64,
     pub signature: Signature,
@@ -21,7 +25,7 @@ mod tests {
     #[test]
     pub fn test_ssz_round_trip() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = Exit::random_for_test(&mut rng);
+        let original = VoluntaryExit::random_for_test(&mut rng);
 
         let bytes = ssz_encode(&original);
         let (decoded, _) = <_>::ssz_decode(&bytes, 0).unwrap();
@@ -32,7 +36,7 @@ mod tests {
     #[test]
     pub fn test_hash_tree_root_internal() {
         let mut rng = XorShiftRng::from_seed([42; 16]);
-        let original = Exit::random_for_test(&mut rng);
+        let original = VoluntaryExit::random_for_test(&mut rng);
 
         let result = original.hash_tree_root_internal();
 

eth2/utils/bls/src/aggregate_public_key.rs

@@ -0,0 +1,24 @@
+use super::PublicKey;
+use bls_aggregates::AggregatePublicKey as RawAggregatePublicKey;
+
+/// A single BLS signature.
+///
+/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ
+/// serialization).
+#[derive(Debug, Clone, Default)]
+pub struct AggregatePublicKey(RawAggregatePublicKey);
+
+impl AggregatePublicKey {
+    pub fn new() -> Self {
+        AggregatePublicKey(RawAggregatePublicKey::new())
+    }
+
+    pub fn add(&mut self, public_key: &PublicKey) {
+        self.0.add(public_key.as_raw())
+    }
+
+    /// Returns the underlying signature.
+    pub fn as_raw(&self) -> &RawAggregatePublicKey {
+        &self.0
+    }
+}

eth2/utils/bls/src/aggregate_signature.rs

@@ -1,5 +1,7 @@
 use super::{AggregatePublicKey, Signature};
-use bls_aggregates::AggregateSignature as RawAggregateSignature;
+use bls_aggregates::{
+    AggregatePublicKey as RawAggregatePublicKey, AggregateSignature as RawAggregateSignature,
+};
 use serde::ser::{Serialize, Serializer};
 use ssz::{
     decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash,
@@ -33,7 +35,38 @@ impl AggregateSignature {
         domain: u64,
         aggregate_public_key: &AggregatePublicKey,
     ) -> bool {
-        self.0.verify(msg, domain, aggregate_public_key)
+        self.0.verify(msg, domain, aggregate_public_key.as_raw())
+    }
+
+    /// Verify this AggregateSignature against multiple AggregatePublickeys with multiple Messages.
+    ///
+    ///  All PublicKeys related to a Message should be aggregated into one AggregatePublicKey.
+    ///  Each AggregatePublicKey has a 1:1 ratio with a 32 byte Message.
+    pub fn verify_multiple(
+        &self,
+        messages: &[&[u8]],
+        domain: u64,
+        aggregate_public_keys: &[&AggregatePublicKey],
+    ) -> bool {
+        // TODO: the API for `RawAggregatePublicKey` shoudn't need to take an owned
+        // `AggregatePublicKey`. There is an issue to fix this, but in the meantime we need to
+        // clone.
+        //
+        // https://github.com/sigp/signature-schemes/issues/10
+        let aggregate_public_keys: Vec<RawAggregatePublicKey> = aggregate_public_keys
+            .iter()
+            .map(|pk| pk.as_raw())
+            .cloned()
+            .collect();
+
+        // Messages are concatenated into one long message.
+        let mut msg: Vec<u8> = vec![];
+        for message in messages {
+            msg.extend_from_slice(message);
+        }
+
+        self.0
+            .verify_multiple(&msg[..], domain, &aggregate_public_keys[..])
     }
 }
 

eth2/utils/bls/src/lib.rs

@@ -1,22 +1,23 @@
 extern crate bls_aggregates;
 extern crate ssz;
 
+mod aggregate_public_key;
 mod aggregate_signature;
 mod keypair;
 mod public_key;
 mod secret_key;
 mod signature;
 
+pub use crate::aggregate_public_key::AggregatePublicKey;
 pub use crate::aggregate_signature::AggregateSignature;
 pub use crate::keypair::Keypair;
 pub use crate::public_key::PublicKey;
 pub use crate::secret_key::SecretKey;
 pub use crate::signature::Signature;
 
-pub use self::bls_aggregates::AggregatePublicKey;
-
 pub const BLS_AGG_SIG_BYTE_SIZE: usize = 96;
 
+use hashing::hash;
 use ssz::ssz_encode;
 
 /// For some signature and public key, ensure that the signature message was the public key and it
@@ -33,6 +34,15 @@ pub fn create_proof_of_possession(keypair: &Keypair) -> Signature {
     Signature::new(&ssz_encode(&keypair.pk), 0, &keypair.sk)
 }
 
+/// Returns the withdrawal credentials for a given public key.
+pub fn get_withdrawal_credentials(pubkey: &PublicKey, prefix_byte: u8) -> Vec<u8> {
+    let hashed = hash(&ssz_encode(pubkey));
+    let mut prefixed = vec![prefix_byte];
+    prefixed.extend_from_slice(&hashed[1..]);
+
+    prefixed
+}
+
 pub fn bls_verify_aggregate(
     pubkey: &AggregatePublicKey,
     message: &[u8],

eth2/utils/fisher_yates_shuffle/Cargo.toml

@@ -4,8 +4,13 @@ version = "0.1.0"
 authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"
 
-[dependencies]
-hashing = { path = "../hashing" }
+[[bench]]
+name = "benches"
+harness = false
 
 [dev-dependencies]
+criterion = "0.2"
 yaml-rust = "0.4.2"
+
+[dependencies]
+hashing = { path = "../hashing" }

eth2/utils/fisher_yates_shuffle/benches/benches.rs

@@ -0,0 +1,55 @@
+use criterion::Criterion;
+use criterion::{black_box, criterion_group, criterion_main, Benchmark};
+use fisher_yates_shuffle::shuffle;
+
+fn get_list(n: usize) -> Vec<usize> {
+    let mut list = Vec::with_capacity(n);
+    for i in 0..n {
+        list.push(i)
+    }
+    assert_eq!(list.len(), n);
+    list
+}
+
+fn shuffles(c: &mut Criterion) {
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("8 elements", move |b| {
+            let seed = vec![42; 32];
+            let list = get_list(8);
+            b.iter_with_setup(|| list.clone(), |list| black_box(shuffle(&seed, list)))
+        }),
+    );
+
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("16 elements", move |b| {
+            let seed = vec![42; 32];
+            let list = get_list(16);
+            b.iter_with_setup(|| list.clone(), |list| black_box(shuffle(&seed, list)))
+        }),
+    );
+
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("512 elements", move |b| {
+            let seed = vec![42; 32];
+            let list = get_list(512);
+            b.iter_with_setup(|| list.clone(), |list| black_box(shuffle(&seed, list)))
+        })
+        .sample_size(10),
+    );
+
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("16384 elements", move |b| {
+            let seed = vec![42; 32];
+            let list = get_list(16_384);
+            b.iter_with_setup(|| list.clone(), |list| black_box(shuffle(&seed, list)))
+        })
+        .sample_size(10),
+    );
+}
+
+criterion_group!(benches, shuffles);
+criterion_main!(benches);

eth2/utils/merkle_proof/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "merkle_proof"
+version = "0.1.0"
+authors = ["Michael Sproul <michael@sigmaprime.io>"]
+edition = "2018"
+
+[dependencies]
+ethereum-types = "0.5"
+hashing = { path = "../hashing" }

eth2/utils/merkle_proof/src/lib.rs

@@ -0,0 +1,148 @@
+use ethereum_types::H256;
+use hashing::hash;
+
+/// Verify a proof that `leaf` exists at `index` in a Merkle tree rooted at `root`.
+///
+/// The `branch` argument is the main component of the proof: it should be a list of internal
+/// node hashes such that the root can be reconstructed (in bottom-up order).
+pub fn verify_merkle_proof(
+    leaf: H256,
+    branch: &[H256],
+    depth: usize,
+    index: usize,
+    root: H256,
+) -> bool {
+    if branch.len() == depth {
+        merkle_root_from_branch(leaf, branch, depth, index) == root
+    } else {
+        false
+    }
+}
+
+/// Compute a root hash from a leaf and a Merkle proof.
+fn merkle_root_from_branch(leaf: H256, branch: &[H256], depth: usize, index: usize) -> H256 {
+    assert_eq!(branch.len(), depth, "proof length should equal depth");
+
+    let mut merkle_root = leaf.as_bytes().to_vec();
+
+    for (i, leaf) in branch.iter().enumerate().take(depth) {
+        let ith_bit = (index >> i) & 0x01;
+        if ith_bit == 1 {
+            let input = concat(leaf.as_bytes().to_vec(), merkle_root);
+            merkle_root = hash(&input);
+        } else {
+            let mut input = merkle_root;
+            input.extend_from_slice(leaf.as_bytes());
+            merkle_root = hash(&input);
+        }
+    }
+
+    H256::from_slice(&merkle_root)
+}
+
+/// Concatenate two vectors.
+fn concat(mut vec1: Vec<u8>, mut vec2: Vec<u8>) -> Vec<u8> {
+    vec1.append(&mut vec2);
+    vec1
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn hash_concat(h1: H256, h2: H256) -> H256 {
+        H256::from_slice(&hash(&concat(
+            h1.as_bytes().to_vec(),
+            h2.as_bytes().to_vec(),
+        )))
+    }
+
+    #[test]
+    fn verify_small_example() {
+        // Construct a small merkle tree manually
+        let leaf_b00 = H256::from([0xAA; 32]);
+        let leaf_b01 = H256::from([0xBB; 32]);
+        let leaf_b10 = H256::from([0xCC; 32]);
+        let leaf_b11 = H256::from([0xDD; 32]);
+
+        let node_b0x = hash_concat(leaf_b00, leaf_b01);
+        let node_b1x = hash_concat(leaf_b10, leaf_b11);
+
+        let root = hash_concat(node_b0x, node_b1x);
+
+        // Run some proofs
+        assert!(verify_merkle_proof(
+            leaf_b00,
+            &[leaf_b01, node_b1x],
+            2,
+            0b00,
+            root
+        ));
+        assert!(verify_merkle_proof(
+            leaf_b01,
+            &[leaf_b00, node_b1x],
+            2,
+            0b01,
+            root
+        ));
+        assert!(verify_merkle_proof(
+            leaf_b10,
+            &[leaf_b11, node_b0x],
+            2,
+            0b10,
+            root
+        ));
+        assert!(verify_merkle_proof(
+            leaf_b11,
+            &[leaf_b10, node_b0x],
+            2,
+            0b11,
+            root
+        ));
+        assert!(verify_merkle_proof(
+            leaf_b11,
+            &[leaf_b10],
+            1,
+            0b11,
+            node_b1x
+        ));
+
+        // Ensure that incorrect proofs fail
+        // Zero-length proof
+        assert!(!verify_merkle_proof(leaf_b01, &[], 2, 0b01, root));
+        // Proof in reverse order
+        assert!(!verify_merkle_proof(
+            leaf_b01,
+            &[node_b1x, leaf_b00],
+            2,
+            0b01,
+            root
+        ));
+        // Proof too short
+        assert!(!verify_merkle_proof(leaf_b01, &[leaf_b00], 2, 0b01, root));
+        // Wrong index
+        assert!(!verify_merkle_proof(
+            leaf_b01,
+            &[leaf_b00, node_b1x],
+            2,
+            0b10,
+            root
+        ));
+        // Wrong root
+        assert!(!verify_merkle_proof(
+            leaf_b01,
+            &[leaf_b00, node_b1x],
+            2,
+            0b01,
+            node_b1x
+        ));
+    }
+
+    #[test]
+    fn verify_zero_depth() {
+        let leaf = H256::from([0xD6; 32]);
+        let junk = H256::from([0xD7; 32]);
+        assert!(verify_merkle_proof(leaf, &[], 0, 0, leaf));
+        assert!(!verify_merkle_proof(leaf, &[], 0, 7, junk));
+    }
+}

eth2/utils/ssz/Cargo.toml

@@ -6,5 +6,5 @@ edition = "2018"
 
 [dependencies]
 bytes = "0.4.9"
-ethereum-types = "0.4.0"
+ethereum-types = "0.5"
 hashing = { path = "../hashing" }

eth2/utils/ssz/src/impl_decode.rs

@@ -59,7 +59,7 @@ impl Decodable for H256 {
         if bytes.len() < 32 || bytes.len() - 32 < index {
             Err(DecodeError::TooShort)
         } else {
-            Ok((H256::from(&bytes[index..(index + 32)]), index + 32))
+            Ok((H256::from_slice(&bytes[index..(index + 32)]), index + 32))
         }
     }
 }
@@ -69,7 +69,7 @@ impl Decodable for Address {
         if bytes.len() < 20 || bytes.len() - 20 < index {
             Err(DecodeError::TooShort)
         } else {
-            Ok((Address::from(&bytes[index..(index + 20)]), index + 20))
+            Ok((Address::from_slice(&bytes[index..(index + 20)]), index + 20))
         }
     }
 }
@@ -95,7 +95,7 @@ mod tests {
          */
         let input = vec![42_u8; 32];
         let (decoded, i) = H256::ssz_decode(&input, 0).unwrap();
-        assert_eq!(decoded.to_vec(), input);
+        assert_eq!(decoded.as_bytes(), &input[..]);
         assert_eq!(i, 32);
 
         /*
@@ -104,7 +104,7 @@ mod tests {
         let mut input = vec![42_u8; 32];
         input.push(12);
         let (decoded, i) = H256::ssz_decode(&input, 0).unwrap();
-        assert_eq!(decoded.to_vec()[..], input[0..32]);
+        assert_eq!(decoded.as_bytes(), &input[0..32]);
         assert_eq!(i, 32);
 
         /*

eth2/utils/ssz/src/impl_encode.rs

@@ -55,13 +55,13 @@ impl Encodable for bool {
 
 impl Encodable for H256 {
     fn ssz_append(&self, s: &mut SszStream) {
-        s.append_encoded_raw(&self.to_vec());
+        s.append_encoded_raw(self.as_bytes());
     }
 }
 
 impl Encodable for Address {
     fn ssz_append(&self, s: &mut SszStream) {
-        s.append_encoded_raw(&self.to_vec());
+        s.append_encoded_raw(self.as_bytes());
     }
 }
 

eth2/utils/ssz/src/lib.rs

@@ -12,6 +12,7 @@ extern crate ethereum_types;
 
 pub mod decode;
 pub mod encode;
+mod signed_root;
 pub mod tree_hash;
 
 mod impl_decode;
@@ -20,6 +21,7 @@ mod impl_tree_hash;
 
 pub use crate::decode::{decode_ssz, decode_ssz_list, Decodable, DecodeError};
 pub use crate::encode::{Encodable, SszStream};
+pub use crate::signed_root::SignedRoot;
 pub use crate::tree_hash::{merkle_hash, TreeHash};
 
 pub use hashing::hash;

eth2/utils/ssz/src/signed_root.rs

@@ -0,0 +1,5 @@
+use crate::TreeHash;
+
+pub trait SignedRoot: TreeHash {
+    fn signed_root(&self) -> Vec<u8>;
+}

eth2/utils/ssz_derive/src/lib.rs

@@ -147,12 +147,87 @@ pub fn ssz_tree_hash_derive(input: TokenStream) -> TokenStream {
     let output = quote! {
         impl ssz::TreeHash for #name {
             fn hash_tree_root_internal(&self) -> Vec<u8> {
-                let mut result: Vec<u8> = vec![];
+                let mut list: Vec<Vec<u8>> = Vec::new();
                 #(
-                    result.append(&mut self.#field_idents.hash_tree_root_internal());
+                    list.push(self.#field_idents.hash_tree_root_internal());
                 )*
 
-                ssz::hash(&result)
+                ssz::merkle_hash(&mut list)
+            }
+        }
+    };
+    output.into()
+}
+
+/// Returns `true` if some `Ident` should be considered to be a signature type.
+fn type_ident_is_signature(ident: &syn::Ident) -> bool {
+    match ident.to_string().as_ref() {
+        "Signature" => true,
+        "AggregateSignature" => true,
+        _ => false,
+    }
+}
+
+/// Takes a `Field` where the type (`ty`) portion is a path (e.g., `types::Signature`) and returns
+/// the final `Ident` in that path.
+///
+/// E.g., for `types::Signature` returns `Signature`.
+fn final_type_ident(field: &syn::Field) -> &syn::Ident {
+    match &field.ty {
+        syn::Type::Path(path) => &path.path.segments.last().unwrap().value().ident,
+        _ => panic!("ssz_derive only supports Path types."),
+    }
+}
+
+/// Implements `ssz::TreeHash` for some `struct`, whilst excluding any fields following and
+/// including a field that is of type "Signature" or "AggregateSignature".
+///
+/// See:
+/// https://github.com/ethereum/eth2.0-specs/blob/master/specs/simple-serialize.md#signed-roots
+///
+/// This is a rather horrendous macro, it will read the type of the object as a string and decide
+/// if it's a signature by matching that string against "Signature" or "AggregateSignature". So,
+/// it's important that you use those exact words as your type -- don't alias it to something else.
+///
+/// If you can think of a better way to do this, please make an issue!
+///
+/// Fields are processed in the order they are defined.
+#[proc_macro_derive(SignedRoot)]
+pub fn ssz_signed_root_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 mut field_idents: Vec<&syn::Ident> = vec![];
+
+    for field in struct_data.fields.iter() {
+        let final_type_ident = final_type_ident(&field);
+
+        if type_ident_is_signature(final_type_ident) {
+            break;
+        } else {
+            let ident = field
+                .ident
+                .as_ref()
+                .expect("ssz_derive only supports named_struct fields.");
+            field_idents.push(ident);
+        }
+    }
+
+    let output = quote! {
+        impl ssz::SignedRoot for #name {
+            fn signed_root(&self) -> Vec<u8> {
+                let mut list: Vec<Vec<u8>> = Vec::new();
+                #(
+                    list.push(self.#field_idents.hash_tree_root_internal());
+                )*
+
+                ssz::merkle_hash(&mut list)
             }
         }
     };

eth2/utils/swap_or_not_shuffle/Cargo.toml

@@ -4,12 +4,17 @@ version = "0.1.0"
 authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"
 
+[[bench]]
+name = "benches"
+harness = false
+
+[dev-dependencies]
+criterion = "0.2"
+yaml-rust = "0.4.2"
+hex = "0.3"
+ethereum-types = "0.5"
+
 [dependencies]
 bytes = "0.4"
 hashing = { path = "../hashing" }
 int_to_bytes = { path = "../int_to_bytes" }
-
-[dev-dependencies]
-yaml-rust = "0.4.2"
-hex = "0.3"
-ethereum-types = "0.5"

eth2/utils/swap_or_not_shuffle/benches/benches.rs

@@ -0,0 +1,92 @@
+use criterion::Criterion;
+use criterion::{black_box, criterion_group, criterion_main, Benchmark};
+use swap_or_not_shuffle::{get_permutated_index, shuffle_list as fast_shuffle};
+
+const SHUFFLE_ROUND_COUNT: u8 = 90;
+
+fn shuffle_list(seed: &[u8], list_size: usize) -> Vec<usize> {
+    let mut output = Vec::with_capacity(list_size);
+    for i in 0..list_size {
+        output.push(get_permutated_index(i, list_size, seed, SHUFFLE_ROUND_COUNT).unwrap());
+    }
+    output
+}
+
+fn shuffles(c: &mut Criterion) {
+    c.bench_function("single swap", move |b| {
+        let seed = vec![42; 32];
+        b.iter(|| black_box(get_permutated_index(0, 10, &seed, SHUFFLE_ROUND_COUNT)))
+    });
+
+    c.bench_function("whole list of size 8", move |b| {
+        let seed = vec![42; 32];
+        b.iter(|| black_box(shuffle_list(&seed, 8)))
+    });
+
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("8 elements", move |b| {
+            let seed = vec![42; 32];
+            b.iter(|| black_box(shuffle_list(&seed, 8)))
+        }),
+    );
+
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("16 elements", move |b| {
+            let seed = vec![42; 32];
+            b.iter(|| black_box(shuffle_list(&seed, 16)))
+        }),
+    );
+
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("512 elements", move |b| {
+            let seed = vec![42; 32];
+            b.iter(|| black_box(shuffle_list(&seed, 512)))
+        })
+        .sample_size(10),
+    );
+
+    c.bench(
+        "_fast_ whole list shuffle",
+        Benchmark::new("512 elements", move |b| {
+            let seed = vec![42; 32];
+            let list: Vec<usize> = (0..512).collect();
+            b.iter(|| black_box(fast_shuffle(list.clone(), SHUFFLE_ROUND_COUNT, &seed, true)))
+        })
+        .sample_size(10),
+    );
+
+    c.bench(
+        "whole list shuffle",
+        Benchmark::new("16384 elements", move |b| {
+            let seed = vec![42; 32];
+            b.iter(|| black_box(shuffle_list(&seed, 16_384)))
+        })
+        .sample_size(10),
+    );
+
+    c.bench(
+        "_fast_ whole list shuffle",
+        Benchmark::new("16384 elements", move |b| {
+            let seed = vec![42; 32];
+            let list: Vec<usize> = (0..16384).collect();
+            b.iter(|| black_box(fast_shuffle(list.clone(), SHUFFLE_ROUND_COUNT, &seed, true)))
+        })
+        .sample_size(10),
+    );
+
+    c.bench(
+        "_fast_ whole list shuffle",
+        Benchmark::new("4m elements", move |b| {
+            let seed = vec![42; 32];
+            let list: Vec<usize> = (0..4_000_000).collect();
+            b.iter(|| black_box(fast_shuffle(list.clone(), SHUFFLE_ROUND_COUNT, &seed, true)))
+        })
+        .sample_size(10),
+    );
+}
+
+criterion_group!(benches, shuffles,);
+criterion_main!(benches);

eth2/utils/swap_or_not_shuffle/src/get_permutated_index.rs

@@ -0,0 +1,187 @@
+use bytes::Buf;
+use hashing::hash;
+use int_to_bytes::{int_to_bytes1, int_to_bytes4};
+use std::cmp::max;
+use std::io::Cursor;
+
+/// Return `p(index)` in a pseudorandom permutation `p` of `0...list_size-1` with ``seed`` as entropy.
+///
+/// Utilizes 'swap or not' shuffling found in
+/// https://link.springer.com/content/pdf/10.1007%2F978-3-642-32009-5_1.pdf
+/// See the 'generalized domain' algorithm on page 3.
+///
+/// Note: this function is significantly slower than the `shuffle_list` function in this crate.
+/// Using `get_permutated_list` to shuffle an entire list, index by index, has been observed to be
+/// 250x slower than `shuffle_list`. Therefore, this function is only useful when shuffling a small
+/// portion of a much larger list.
+///
+/// Returns `None` under any of the following conditions:
+///  - `list_size == 0`
+///  - `index >= list_size`
+///  - `list_size > 2**24`
+///  - `list_size > usize::max_value() / 2`
+pub fn get_permutated_index(
+    index: usize,
+    list_size: usize,
+    seed: &[u8],
+    shuffle_round_count: u8,
+) -> Option<usize> {
+    if list_size == 0
+        || index >= list_size
+        || list_size > usize::max_value() / 2
+        || list_size > 2_usize.pow(24)
+    {
+        return None;
+    }
+
+    let mut index = index;
+    for round in 0..shuffle_round_count {
+        let pivot = bytes_to_int64(&hash_with_round(seed, round)[..]) as usize % list_size;
+        index = do_round(seed, index, pivot, round, list_size)?;
+    }
+    Some(index)
+}
+
+fn do_round(seed: &[u8], index: usize, pivot: usize, round: u8, list_size: usize) -> Option<usize> {
+    let flip = (pivot + list_size - index) % list_size;
+    let position = max(index, flip);
+    let source = hash_with_round_and_position(seed, round, position)?;
+    let byte = source[(position % 256) / 8];
+    let bit = (byte >> (position % 8)) % 2;
+    Some(if bit == 1 { flip } else { index })
+}
+
+fn hash_with_round_and_position(seed: &[u8], round: u8, position: usize) -> Option<Vec<u8>> {
+    let mut seed = seed.to_vec();
+    seed.append(&mut int_to_bytes1(round));
+    /*
+     * Note: the specification has an implicit assertion in `int_to_bytes4` that `position / 256 <
+     * 2**24`. For efficiency, we do not check for that here as it is checked in `get_permutated_index`.
+     */
+    seed.append(&mut int_to_bytes4((position / 256) as u32));
+    Some(hash(&seed[..]))
+}
+
+fn hash_with_round(seed: &[u8], round: u8) -> Vec<u8> {
+    let mut seed = seed.to_vec();
+    seed.append(&mut int_to_bytes1(round));
+    hash(&seed[..])
+}
+
+fn bytes_to_int64(bytes: &[u8]) -> u64 {
+    let mut cursor = Cursor::new(bytes);
+    cursor.get_u64_le()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ethereum_types::H256 as Hash256;
+    use hex;
+    use std::{fs::File, io::prelude::*, path::PathBuf};
+    use yaml_rust::yaml;
+
+    #[test]
+    #[ignore]
+    fn fuzz_test() {
+        let max_list_size = 2_usize.pow(24);
+        let test_runs = 1000;
+
+        // Test at max list_size with the end index.
+        for _ in 0..test_runs {
+            let index = max_list_size - 1;
+            let list_size = max_list_size;
+            let seed = Hash256::random();
+            let shuffle_rounds = 90;
+
+            assert!(get_permutated_index(index, list_size, &seed[..], shuffle_rounds).is_some());
+        }
+
+        // Test at max list_size low indices.
+        for i in 0..test_runs {
+            let index = i;
+            let list_size = max_list_size;
+            let seed = Hash256::random();
+            let shuffle_rounds = 90;
+
+            assert!(get_permutated_index(index, list_size, &seed[..], shuffle_rounds).is_some());
+        }
+
+        // Test at max list_size high indices.
+        for i in 0..test_runs {
+            let index = max_list_size - 1 - i;
+            let list_size = max_list_size;
+            let seed = Hash256::random();
+            let shuffle_rounds = 90;
+
+            assert!(get_permutated_index(index, list_size, &seed[..], shuffle_rounds).is_some());
+        }
+    }
+
+    #[test]
+    fn returns_none_for_zero_length_list() {
+        assert_eq!(None, get_permutated_index(100, 0, &[42, 42], 90));
+    }
+
+    #[test]
+    fn returns_none_for_out_of_bounds_index() {
+        assert_eq!(None, get_permutated_index(100, 100, &[42, 42], 90));
+    }
+
+    #[test]
+    fn returns_none_for_too_large_list() {
+        assert_eq!(
+            None,
+            get_permutated_index(100, usize::max_value() / 2, &[42, 42], 90)
+        );
+    }
+
+    #[test]
+    fn test_vectors() {
+        /*
+         * Test vectors are generated here:
+         *
+         * https://github.com/ethereum/eth2.0-test-generators
+         */
+        let mut file = {
+            let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            file_path_buf.push("src/specs/test_vector_permutated_index.yml");
+
+            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];
+        let test_cases = doc["test_cases"].as_vec().unwrap();
+
+        for (i, test_case) in test_cases.iter().enumerate() {
+            let index = test_case["index"].as_i64().unwrap() as usize;
+            let list_size = test_case["list_size"].as_i64().unwrap() as usize;
+            let permutated_index = test_case["permutated_index"].as_i64().unwrap() as usize;
+            let shuffle_round_count = test_case["shuffle_round_count"].as_i64().unwrap();
+            let seed_string = test_case["seed"].clone().into_string().unwrap();
+            let seed = hex::decode(seed_string.replace("0x", "")).unwrap();
+
+            let shuffle_round_count = if shuffle_round_count < (u8::max_value() as i64) {
+                shuffle_round_count as u8
+            } else {
+                panic!("shuffle_round_count must be a u8")
+            };
+
+            assert_eq!(
+                Some(permutated_index),
+                get_permutated_index(index, list_size, &seed[..], shuffle_round_count),
+                "Failure on case #{} index: {}, list_size: {}, round_count: {}, seed: {}",
+                i,
+                index,
+                list_size,
+                shuffle_round_count,
+                seed_string,
+            );
+        }
+    }
+}

eth2/utils/swap_or_not_shuffle/src/lib.rs

@@ -1,178 +1,21 @@
-use bytes::Buf;
-use hashing::hash;
-use int_to_bytes::{int_to_bytes1, int_to_bytes4};
-use std::cmp::max;
-use std::io::Cursor;
+//! Provides list-shuffling functions matching the Ethereum 2.0 specification.
+//!
+//! See
+//! [get_permutated_index](https://github.com/ethereum/eth2.0-specs/blob/0.4.0/specs/core/0_beacon-chain.md#get_permuted_index)
+//! for specifications.
+//!
+//! There are two functions exported by this crate:
+//!
+//! - `get_permutated_index`: given a single index, computes the index resulting from a shuffle.
+//! Runs in less time than it takes to run `shuffle_list`.
+//! - `shuffle_list`: shuffles an entire list in-place. Runs in less time than it takes to run
+//! `get_permutated_index` on each index.
+//!
+//! In general, use `get_permutated_list` to calculate the shuffling of a small subset of a much
+//! larger list (~250x larger is a good guide, but solid figures yet to be calculated).
 
-/// Return `p(index)` in a pseudorandom permutation `p` of `0...list_size-1` with ``seed`` as entropy.
-///
-/// Utilizes 'swap or not' shuffling found in
-/// https://link.springer.com/content/pdf/10.1007%2F978-3-642-32009-5_1.pdf
-/// See the 'generalized domain' algorithm on page 3.
-///
-/// Returns `None` under any of the following conditions:
-///  - `list_size == 0`
-///  - `index >= list_size`
-///  - `list_size > 2**24`
-///  - `list_size > usize::max_value() / 2`
-pub fn get_permutated_index(
-    index: usize,
-    list_size: usize,
-    seed: &[u8],
-    shuffle_round_count: u8,
-) -> Option<usize> {
-    if list_size == 0
-        || index >= list_size
-        || list_size > usize::max_value() / 2
-        || list_size > 2_usize.pow(24)
-    {
-        return None;
-    }
+mod get_permutated_index;
+mod shuffle_list;
 
-    let mut index = index;
-    for round in 0..shuffle_round_count {
-        let pivot = bytes_to_int64(&hash_with_round(seed, round)[..]) as usize % list_size;
-        let flip = (pivot + list_size - index) % list_size;
-        let position = max(index, flip);
-        let source = hash_with_round_and_position(seed, round, position)?;
-        let byte = source[(position % 256) / 8];
-        let bit = (byte >> (position % 8)) % 2;
-        index = if bit == 1 { flip } else { index }
-    }
-    Some(index)
-}
-
-fn hash_with_round_and_position(seed: &[u8], round: u8, position: usize) -> Option<Vec<u8>> {
-    let mut seed = seed.to_vec();
-    seed.append(&mut int_to_bytes1(round));
-    /*
-     * Note: the specification has an implicit assertion in `int_to_bytes4` that `position / 256 <
-     * 2**24`. For efficiency, we do not check for that here as it is checked in `get_permutated_index`.
-     */
-    seed.append(&mut int_to_bytes4((position / 256) as u32));
-    Some(hash(&seed[..]))
-}
-
-fn hash_with_round(seed: &[u8], round: u8) -> Vec<u8> {
-    let mut seed = seed.to_vec();
-    seed.append(&mut int_to_bytes1(round));
-    hash(&seed[..])
-}
-
-fn bytes_to_int64(bytes: &[u8]) -> u64 {
-    let mut cursor = Cursor::new(bytes);
-    cursor.get_u64_le()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ethereum_types::H256 as Hash256;
-    use hex;
-    use std::{fs::File, io::prelude::*, path::PathBuf};
-    use yaml_rust::yaml;
-
-    #[test]
-    #[ignore]
-    fn fuzz_test() {
-        let max_list_size = 2_usize.pow(24);
-        let test_runs = 1000;
-
-        // Test at max list_size with the end index.
-        for _ in 0..test_runs {
-            let index = max_list_size - 1;
-            let list_size = max_list_size;
-            let seed = Hash256::random();
-            let shuffle_rounds = 90;
-
-            assert!(get_permutated_index(index, list_size, &seed[..], shuffle_rounds).is_some());
-        }
-
-        // Test at max list_size low indices.
-        for i in 0..test_runs {
-            let index = i;
-            let list_size = max_list_size;
-            let seed = Hash256::random();
-            let shuffle_rounds = 90;
-
-            assert!(get_permutated_index(index, list_size, &seed[..], shuffle_rounds).is_some());
-        }
-
-        // Test at max list_size high indices.
-        for i in 0..test_runs {
-            let index = max_list_size - 1 - i;
-            let list_size = max_list_size;
-            let seed = Hash256::random();
-            let shuffle_rounds = 90;
-
-            assert!(get_permutated_index(index, list_size, &seed[..], shuffle_rounds).is_some());
-        }
-    }
-
-    #[test]
-    fn returns_none_for_zero_length_list() {
-        assert_eq!(None, get_permutated_index(100, 0, &[42, 42], 90));
-    }
-
-    #[test]
-    fn returns_none_for_out_of_bounds_index() {
-        assert_eq!(None, get_permutated_index(100, 100, &[42, 42], 90));
-    }
-
-    #[test]
-    fn returns_none_for_too_large_list() {
-        assert_eq!(
-            None,
-            get_permutated_index(100, usize::max_value() / 2, &[42, 42], 90)
-        );
-    }
-
-    #[test]
-    fn test_vectors() {
-        /*
-         * Test vectors are generated here:
-         *
-         * https://github.com/ethereum/eth2.0-test-generators
-         */
-        let mut file = {
-            let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-            file_path_buf.push("src/specs/test_vector_permutated_index.yml");
-
-            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];
-        let test_cases = doc["test_cases"].as_vec().unwrap();
-
-        for (i, test_case) in test_cases.iter().enumerate() {
-            let index = test_case["index"].as_i64().unwrap() as usize;
-            let list_size = test_case["list_size"].as_i64().unwrap() as usize;
-            let permutated_index = test_case["permutated_index"].as_i64().unwrap() as usize;
-            let shuffle_round_count = test_case["shuffle_round_count"].as_i64().unwrap();
-            let seed_string = test_case["seed"].clone().into_string().unwrap();
-            let seed = hex::decode(seed_string.replace("0x", "")).unwrap();
-
-            let shuffle_round_count = if shuffle_round_count < (u8::max_value() as i64) {
-                shuffle_round_count as u8
-            } else {
-                panic!("shuffle_round_count must be a u8")
-            };
-
-            assert_eq!(
-                Some(permutated_index),
-                get_permutated_index(index, list_size, &seed[..], shuffle_round_count),
-                "Failure on case #{} index: {}, list_size: {}, round_count: {}, seed: {}",
-                i,
-                index,
-                list_size,
-                shuffle_round_count,
-                seed_string,
-            );
-        }
-    }
-}
+pub use get_permutated_index::get_permutated_index;
+pub use shuffle_list::shuffle_list;

eth2/utils/swap_or_not_shuffle/src/shuffle_list.rs

@@ -0,0 +1,178 @@
+use bytes::Buf;
+use hashing::hash;
+use int_to_bytes::int_to_bytes4;
+use std::io::Cursor;
+
+const SEED_SIZE: usize = 32;
+const ROUND_SIZE: usize = 1;
+const POSITION_WINDOW_SIZE: usize = 4;
+const PIVOT_VIEW_SIZE: usize = SEED_SIZE + ROUND_SIZE;
+const TOTAL_SIZE: usize = SEED_SIZE + ROUND_SIZE + POSITION_WINDOW_SIZE;
+
+/// Shuffles an entire list in-place.
+///
+/// Note: this is equivalent to the `get_permutated_index` function, except it shuffles an entire
+/// list not just a single index. With large lists this function has been observed to be 250x
+/// faster than running `get_permutated_index` across an entire list.
+///
+/// Credits to [@protolambda](https://github.com/protolambda) for defining this algorithm.
+///
+/// Shuffles if `forwards == true`, otherwise un-shuffles.
+///
+/// Returns `None` under any of the following conditions:
+///  - `list_size == 0`
+///  - `list_size > 2**24`
+///  - `list_size > usize::max_value() / 2`
+pub fn shuffle_list(
+    mut input: Vec<usize>,
+    rounds: u8,
+    seed: &[u8],
+    forwards: bool,
+) -> Option<Vec<usize>> {
+    let list_size = input.len();
+
+    if input.is_empty()
+        || list_size > usize::max_value() / 2
+        || list_size > 2_usize.pow(24)
+        || rounds == 0
+    {
+        return None;
+    }
+
+    let mut buf: Vec<u8> = Vec::with_capacity(TOTAL_SIZE);
+
+    let mut r = if forwards { 0 } else { rounds - 1 };
+
+    buf.extend_from_slice(seed);
+
+    loop {
+        buf.splice(SEED_SIZE.., vec![r]);
+
+        let pivot = bytes_to_int64(&hash(&buf[0..PIVOT_VIEW_SIZE])[0..8]) as usize % list_size;
+
+        let mirror = (pivot + 1) >> 1;
+
+        buf.splice(PIVOT_VIEW_SIZE.., int_to_bytes4((pivot >> 8) as u32));
+        let mut source = hash(&buf[..]);
+        let mut byte_v = source[(pivot & 0xff) >> 3];
+
+        for i in 0..mirror {
+            let j = pivot - i;
+
+            if j & 0xff == 0xff {
+                buf.splice(PIVOT_VIEW_SIZE.., int_to_bytes4((j >> 8) as u32));
+                source = hash(&buf[..]);
+            }
+
+            if j & 0x07 == 0x07 {
+                byte_v = source[(j & 0xff) >> 3];
+            }
+            let bit_v = (byte_v >> (j & 0x07)) & 0x01;
+
+            if bit_v == 1 {
+                input.swap(i, j);
+            }
+        }
+
+        let mirror = (pivot + list_size + 1) >> 1;
+        let end = list_size - 1;
+
+        buf.splice(PIVOT_VIEW_SIZE.., int_to_bytes4((end >> 8) as u32));
+        let mut source = hash(&buf[..]);
+        let mut byte_v = source[(end & 0xff) >> 3];
+
+        for (loop_iter, i) in ((pivot + 1)..mirror).enumerate() {
+            let j = end - loop_iter;
+
+            if j & 0xff == 0xff {
+                buf.splice(PIVOT_VIEW_SIZE.., int_to_bytes4((j >> 8) as u32));
+                source = hash(&buf[..]);
+            }
+
+            if j & 0x07 == 0x07 {
+                byte_v = source[(j & 0xff) >> 3];
+            }
+            let bit_v = (byte_v >> (j & 0x07)) & 0x01;
+
+            if bit_v == 1 {
+                input.swap(i, j);
+            }
+        }
+
+        if forwards {
+            r += 1;
+            if r == rounds {
+                break;
+            }
+        } else {
+            if r == 0 {
+                break;
+            }
+            r -= 1;
+        }
+    }
+
+    Some(input)
+}
+
+fn bytes_to_int64(bytes: &[u8]) -> u64 {
+    let mut cursor = Cursor::new(bytes);
+    cursor.get_u64_le()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use hex;
+    use std::{fs::File, io::prelude::*, path::PathBuf};
+    use yaml_rust::yaml;
+
+    #[test]
+    fn returns_none_for_zero_length_list() {
+        assert_eq!(None, shuffle_list(vec![], 90, &[42, 42], true));
+    }
+
+    #[test]
+    fn test_vectors() {
+        let mut file = {
+            let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            file_path_buf.push("src/specs/test_vector_permutated_index.yml");
+
+            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];
+        let test_cases = doc["test_cases"].as_vec().unwrap();
+
+        for (i, test_case) in test_cases.iter().enumerate() {
+            let index = test_case["index"].as_i64().unwrap() as usize;
+            let list_size = test_case["list_size"].as_i64().unwrap() as usize;
+            let permutated_index = test_case["permutated_index"].as_i64().unwrap() as usize;
+            let shuffle_round_count = test_case["shuffle_round_count"].as_i64().unwrap();
+            let seed_string = test_case["seed"].clone().into_string().unwrap();
+            let seed = hex::decode(seed_string.replace("0x", "")).unwrap();
+
+            let shuffle_round_count = if shuffle_round_count < (u8::max_value() as i64) {
+                shuffle_round_count as u8
+            } else {
+                panic!("shuffle_round_count must be a u8")
+            };
+
+            let list: Vec<usize> = (0..list_size).collect();
+
+            let shuffled =
+                shuffle_list(list.clone(), shuffle_round_count, &seed[..], true).unwrap();
+
+            assert_eq!(
+                list[index], shuffled[permutated_index],
+                "Failure on case #{} index: {}, list_size: {}, round_count: {}, seed: {}",
+                i, index, list_size, shuffle_round_count, seed_string
+            );
+        }
+    }
+}